home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 14 / CU Amiga Magazine's Super CD-ROM 14 (1997)(EMAP Images)(GB)(Track 1 of 3)[!][issue 1997-09].iso / CUCD / Programming / IEditor / gadgets.c < prev    next >
C/C++ Source or Header  |  1997-06-17  |  139KB  |  6,013 lines
  1. /// Include
  2. #include <stdarg.h>
  3. #include <string.h>
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6.  
  7.  
  8. #define INTUI_V36_NAMES_ONLY
  9. #define ASL_V38_NAMES_ONLY
  10. #define CATCOMP_NUMBERS
  11.  
  12. #include <exec/nodes.h>                 // exec
  13. #include <exec/lists.h>
  14. #include <exec/memory.h>
  15. #include <exec/types.h>
  16. #include <graphics/rastport.h>          // graphics
  17. #include <intuition/intuition.h>        // intuition
  18. #include <dos/dos.h>                    // dos
  19. #include <libraries/gadtools.h>         // libraries
  20. #include <libraries/asl.h>
  21. #include <clib/exec_protos.h>           // protos
  22. #include <clib/intuition_protos.h>
  23. #include <clib/graphics_protos.h>
  24. #include <clib/dos_protos.h>
  25. #include <clib/locale_protos.h>
  26. #include <clib/asl_protos.h>
  27. #include <clib/gadtools_protos.h>
  28. #include <pragmas/exec_pragmas.h>       // pragmas
  29. #include <pragmas/intuition_pragmas.h>
  30. #include <pragmas/graphics_pragmas.h>
  31. #include <pragmas/dos_pragmas.h>
  32. #include <pragmas/asl_pragmas.h>
  33. #include <pragmas/gadtools_pragmas.h>
  34. #include <pragmas/locale_pragmas.h>
  35.  
  36.  
  37. #include "DEV_IE:defs.h"
  38. #include "DEV_IE:GUI.h"
  39. #include "DEV_IE:GUI_locale.h"
  40. #include "DEV_IE:Include/expander_pragmas.h"
  41. ///
  42. /// Prototipi
  43. static BOOL     CopiaBooleano( struct BooleanInfo *, WORD, WORD );
  44. static BOOL     Resizable( struct GadgetInfo * );
  45. static UWORD    CheckResizeGad( void );
  46. static BOOL     TraceGadRect( UWORD, WORD *, WORD * );
  47. static void     RedrawResize( UWORD, WORD, WORD );
  48. static BOOL     MuoviGadgets( struct GadgetInfo *, WORD, WORD, WORD *, WORD *, UWORD );
  49. static BOOL     Attiva( WORD, WORD, WORD, WORD );
  50. static BOOL     AttivaUno( WORD, WORD );
  51. static void     IntegerDefault( struct GadgetInfo * );
  52. static void     ListviewDefault( struct GadgetInfo * );
  53. static void     MxDefault( struct GadgetInfo * );
  54. static void     NumberDefault( struct GadgetInfo * );
  55. static void     CycleDefault( struct GadgetInfo * );
  56. static void     PaletteDefault( struct GadgetInfo * );
  57. static void     ScrollerDefault( struct GadgetInfo * );
  58. static void     SliderDefault( struct GadgetInfo * );
  59. static void     StringDefault( struct GadgetInfo * );
  60. static void     TextDefault( struct GadgetInfo * );
  61. static void     SetButtonTag( ULONG *, ULONG, struct GadgetInfo * );
  62. static void     SetCheckboxTag( ULONG *, ULONG, struct GadgetInfo * );
  63. static void     SetIntegerTag( ULONG *, ULONG, struct GadgetInfo * );
  64. static void     SetListviewTag( ULONG *, ULONG, struct GadgetInfo * );
  65. static void     SetMxTag( ULONG *, ULONG, struct GadgetInfo * );
  66. static void     SetNumberTag( ULONG *, ULONG, struct GadgetInfo * );
  67. static void     SetCycleTag( ULONG *, ULONG, struct GadgetInfo * );
  68. static void     SetPaletteTag( ULONG *, ULONG, struct GadgetInfo * );
  69. static void     SetScrollerTag( ULONG *, ULONG, struct GadgetInfo * );
  70. static void     SetSliderTag( ULONG *, ULONG, struct GadgetInfo * );
  71. static void     SetStringTag( ULONG *, ULONG, struct GadgetInfo * );
  72. static void     SetTextTag( ULONG *, ULONG, struct GadgetInfo * );
  73. static void     ListEdStaccaLista( void );
  74. static void     ListEdAttaccaLista( void );
  75. static void     AttivaListEdGadgets( void );
  76. static void     DisattivaListEdGadgets( void );
  77. static void     SettaListEdIn( void );
  78. static void     ParametriButton( struct GadgetInfo * );
  79. static void     ParametriCheckbox( struct GadgetInfo * );
  80. static void     ParametriInteger( struct GadgetInfo * );
  81. static void     ParametriListview( struct GadgetInfo * );
  82. static void     ParametriMx( struct GadgetInfo * );
  83. static void     ParametriNumber( struct GadgetInfo * );
  84. static void     ParametriCycle( struct GadgetInfo * );
  85. static void     ParametriPalette( struct GadgetInfo * );
  86. static void     ParametriScroller( struct GadgetInfo * );
  87. static void     ParametriSlider( struct GadgetInfo * );
  88. static void     ParametriString( struct GadgetInfo * );
  89. static void     ParametriText( struct GadgetInfo * );
  90. ///
  91. /// Dati
  92. WORD    lastx, lasty;
  93. APTR    buffer4;
  94.  
  95. static  ULONG   BackValue;
  96.  
  97. ULONG   gadget_flags[] = { 1, 2, 4, 8, 16, 0 };
  98.  
  99. struct MinList  ListEd_List;
  100.  
  101. static ULONG menugad_on[] = {
  102.         (1<<5)|2,
  103.         (2<<5)|2,
  104.         (4<<5)|2,
  105.         (5<<5)|2,
  106.         (-1<<11)|(6<<5)|2,
  107.         (7<<5)|2,
  108.         (-1<<11)|(9<<5)|2,
  109.         (-1<<11)|(10<<5)|2,
  110.         (-1<<11)|(11<<5)|2,
  111.         (-1<<11)|(12<<5)|2,
  112.         (13<<5)|2,
  113.         (14<<5)|2,
  114.         (16<<5)|2
  115.     };
  116.  
  117. #define GADMENU_NUM 13
  118.  
  119. struct GXY gadgetxy_index[] = {
  120.         0, 0, 0,     // non esiste un Kind == 0
  121.         0, 0, TRUE,
  122.         CHECKBOX_WIDTH, CHECKBOX_HEIGHT, FALSE,
  123.         0, 0, TRUE,
  124.         0, 0, TRUE,
  125.         MX_WIDTH, MX_HEIGHT, FALSE,
  126.         0, 0, TRUE,
  127.         0, 0, TRUE,
  128.         0, 0, TRUE,
  129.         0, 0, TRUE,
  130.         0, 0, TRUE,
  131.         0, 0, TRUE,
  132.         0, 0, TRUE,
  133.         0, 0, TRUE,
  134.         0, 0, TRUE,
  135.     };
  136.  
  137. APTR pre_gadget_index[] = {
  138.         NULL,
  139.         NULL,
  140.         (APTR)IntegerDefault,
  141.         (APTR)ListviewDefault,
  142.         (APTR)MxDefault,
  143.         (APTR)NumberDefault,
  144.         (APTR)CycleDefault,
  145.         (APTR)PaletteDefault,
  146.         (APTR)ScrollerDefault,
  147.         NULL,
  148.         (APTR)SliderDefault,
  149.         (APTR)StringDefault,
  150.         (APTR)TextDefault
  151.     };
  152.  
  153. UWORD stringjusts[] = { GACT_STRINGLEFT, GACT_STRINGRIGHT, GACT_STRINGCENTER };
  154.  
  155. static ULONG button_newtag[] = {
  156.     GT_Underscore, '_', GA_Disabled, FALSE, TAG_END };
  157. static ULONG checkbox_newtag[] = {
  158.     GT_Underscore, '_', GA_Disabled, FALSE, GTCB_Checked, FALSE, GTCB_Scaled, FALSE, TAG_END };
  159. static ULONG integer_newtag[] = {
  160.     GT_Underscore, '_', GTIN_Number, 0, STRINGA_Justification, 0, GA_Disabled, 0, GA_TabCycle, 0, STRINGA_ReplaceMode, 0, TAG_END };
  161. static ULONG listview_newtag[] = {
  162.     GT_Underscore, '_', GTLV_ScrollWidth, 0, LAYOUTA_Spacing, 0, GA_Disabled, FALSE, GTLV_Labels, 0, GTLV_ReadOnly, 0, TAG_END };
  163. static ULONG mx_newtag[] = {
  164.     GT_Underscore, '_', GTMX_Labels, 0, GTMX_Active, 0, GTMX_Spacing, 0, GTMX_TitlePlace, 0, GA_Disabled, FALSE, GTMX_Scaled, 0, TAG_END };
  165. static ULONG number_newtag[] = {
  166.     GT_Underscore, '_', GTNM_Number, 0, GTNM_Justification, 0, GTNM_MaxNumberLen, 0, GTNM_Border, 0, GTNM_Clipped, 0, GTNM_Format, 0, GTNM_FrontPen, 0, GTNM_BackPen, 0, TAG_END };
  167. static ULONG cycle_newtag[] = {
  168.     GT_Underscore, '_', GTCY_Labels, 0, GTCY_Active, 0, GA_Disabled, FALSE, TAG_END };
  169. static ULONG palette_newtag[] = {
  170.     GT_Underscore, '_', GTPA_Depth, 0, GTPA_Color, 0, GTPA_ColorOffset, 0, GTPA_IndicatorWidth, 0, GTPA_IndicatorHeight, 0, GTPA_NumColors, 0, GA_Disabled, FALSE, TAG_END };
  171. static ULONG scroller_newtag[] = {
  172.     GT_Underscore, '_', GTSC_Top, 0, GTSC_Total, 0, GTSC_Visible, 0, GTSC_Arrows, 0, PGA_Freedom, 0, GA_Disabled, FALSE, TAG_END };
  173. static ULONG slider_newtag[] = {
  174.     GT_Underscore, '_', GTSL_Min, 0, GTSL_Max, 0, GTSL_Level, 0, GTSL_MaxLevelLen, 0, GTSL_LevelFormat, 0, GTSL_LevelPlace, 0, GTSL_MaxPixelLen, 0, GTSL_Justification, 0, PGA_Freedom, 0, GA_Disabled, FALSE, TAG_END };
  175. static ULONG string_newtag[] = {
  176.     GT_Underscore, '_', GTST_MaxChars, 0, STRINGA_Justification, 0, GTST_String, 0, GA_Disabled, FALSE, GA_TabCycle, 0, STRINGA_ExitHelp, 0, STRINGA_ReplaceMode, 0, TAG_END };
  177. static ULONG text_newtag[] = {
  178.     GT_Underscore, '_', GTTX_Justification, 0, GTTX_Text, 0, GTTX_Border, 0, GTTX_Clipped, 0, GTTX_FrontPen, 0, GTTX_BackPen, 0, TAG_END };
  179.  
  180. APTR newtags_index[] = {
  181.         button_newtag,
  182.         checkbox_newtag,
  183.         integer_newtag,
  184.         listview_newtag,
  185.         mx_newtag,
  186.         number_newtag,
  187.         cycle_newtag,
  188.         palette_newtag,
  189.         scroller_newtag,
  190.         NULL,
  191.         slider_newtag,
  192.         string_newtag,
  193.         text_newtag
  194.     };
  195.  
  196. APTR settag_index[] = {
  197.         NULL,
  198.         (APTR)SetButtonTag,
  199.         (APTR)SetCheckboxTag,
  200.         (APTR)SetIntegerTag,
  201.         (APTR)SetListviewTag,
  202.         (APTR)SetMxTag,
  203.         (APTR)SetNumberTag,
  204.         (APTR)SetCycleTag,
  205.         (APTR)SetPaletteTag,
  206.         (APTR)SetScrollerTag,
  207.         NULL,
  208.         (APTR)SetSliderTag,
  209.         (APTR)SetStringTag,
  210.         (APTR)SetTextTag
  211.     };
  212.  
  213. APTR modifica_index[] = {
  214.         NULL,
  215.         (APTR)ParametriButton,
  216.         (APTR)ParametriCheckbox,
  217.         (APTR)ParametriInteger,
  218.         (APTR)ParametriListview,
  219.         (APTR)ParametriMx,
  220.         (APTR)ParametriNumber,
  221.         (APTR)ParametriCycle,
  222.         (APTR)ParametriPalette,
  223.         (APTR)ParametriScroller,
  224.         NULL,
  225.         (APTR)ParametriSlider,
  226.         (APTR)ParametriString,
  227.         (APTR)ParametriText,
  228.         (APTR)ParametriBooleano
  229.     };
  230. ///
  231.  
  232.  
  233.  
  234. /// TestAttivi
  235. BOOL TestAttivi( void )
  236. {
  237.     BOOL                ret = FALSE;
  238.     struct GadgetInfo  *gad;
  239.  
  240.     for( gad = IE.win_info->wi_Gadgets.mlh_Head; gad->g_Node.ln_Succ; gad = gad->g_Node.ln_Succ ) {
  241.     if( gad->g_flags2 & G_ATTIVO )
  242.         ret = TRUE;
  243.     }
  244.  
  245.     return( ret );
  246. }
  247. ///
  248.  
  249. /// CheckSize  ( controllo dimensioni minime gadget )
  250. void CheckSize( struct GadgetInfo *gad )
  251. {
  252.     UWORD   x;
  253.  
  254.     if(!( gad->g_Width ))
  255.     gad->g_Width = 1;
  256.  
  257.     switch( gad->g_Kind ) {
  258.  
  259.     case STRING_KIND:
  260.     case INTEGER_KIND:
  261.     case TEXT_KIND:
  262.     case NUMBER_KIND:
  263.         x = Scr->Font->ta_YSize + 1;
  264.         if( gad->g_Height < x )
  265.         gad->g_Height = x;
  266.     break;
  267.  
  268.     case LISTVIEW_KIND:
  269.         if( gad->g_Height < 12 )
  270.         gad->g_Height = 12;
  271.         break;
  272.  
  273.     default:
  274.         if(!( gad->g_Height ))
  275.         gad->g_Height = 1;
  276.         break;
  277.     }
  278. }
  279. ///
  280.  
  281. /// GetGad
  282. struct GadgetInfo *GetGad( void )
  283. {
  284.     struct GadgetInfo      *gad = NULL, *gad2;
  285.     struct IntuiMessage    *msg;
  286.     ULONG                   class;
  287.     int                     code, x, y;
  288.     BOOL                    ok = TRUE;
  289.  
  290.     StaccaGadgets();
  291.  
  292.     Stat( CatCompArray[ MSG_CLICK ].cca_Str, FALSE, 0 );
  293.  
  294.     do {
  295.  
  296.     WaitPort( IE.win_active->UserPort );
  297.  
  298.     while( msg = GT_GetIMsg( IE.win_active->UserPort )) {
  299.  
  300.         class = msg->Class;
  301.         code  = msg->Code;
  302.         x     = msg->MouseX;
  303.         y     = msg->MouseY;
  304.  
  305.         GT_ReplyIMsg( msg );
  306.  
  307.         switch( class ) {
  308.  
  309.         case IDCMP_VANILLAKEY:
  310.             if( code == 27 ) {
  311.             ok = FALSE;
  312.             Stat( CatCompArray[ MSG_ABORTED ].cca_Str, FALSE, 0 );
  313.             }
  314.             break;
  315.  
  316.         case IDCMP_REFRESHWINDOW:
  317.             RinfrescaFinestra();
  318.             break;
  319.  
  320.         case IDCMP_MOUSEBUTTONS:
  321.             switch( code ) {
  322.             case 0x69:
  323.                 ok = FALSE;
  324.                 Stat( CatCompArray[ MSG_ABORTED ].cca_Str, FALSE, 0 );
  325.                 break;
  326.  
  327.             case 0x68:
  328.                 for( gad2 = IE.win_info->wi_Gadgets.mlh_Head; gad2->g_Node.ln_Succ; gad2 = gad2->g_Node.ln_Succ ) {
  329.                 BOOL can = FALSE;
  330.  
  331.                 if( gad2->g_Kind < MIN_IEX_ID )
  332.                     can = TRUE;
  333.                 else {
  334.                     struct IEXNode *ex;
  335.  
  336.                     ex = IE.Expanders.mlh_Head;
  337.                     while( ex->ID != gad2->g_Kind )
  338.                     ex = ex->Node.ln_Succ;
  339.  
  340.                     if( ex->Base->Movable || ex->Base->Resizable )
  341.                     can = TRUE;
  342.                 }
  343.  
  344.                 if(( can ) && (( x >= gad2->g_Left ) && ( x < gad2->g_Left + gad2->g_Width ) && ( y >= gad2->g_Top ) && ( y < gad2->g_Top + gad2->g_Height ))) {
  345.                     ok = FALSE;
  346.                     gad2->g_flags2 |= G_WAS_ACTIVE;
  347.                 }
  348.                 }
  349.  
  350.                 if(!( ok )) {
  351.                 ULONG area = 0xffffffff, area2;
  352.  
  353.                 for( gad2 = IE.win_info->wi_Gadgets.mlh_Head; gad2->g_Node.ln_Succ; gad2 = gad2->g_Node.ln_Succ ) {
  354.                     if( gad2->g_flags2 & G_WAS_ACTIVE ) {
  355.                     gad2->g_flags2 &= ~G_WAS_ACTIVE;
  356.  
  357.                     area2 = gad2->g_Width * gad2->g_Height;
  358.  
  359.                     if( area2 < area ) {
  360.                         gad = gad2;
  361.                         area = area2;
  362.                     }
  363.                     }
  364.                 }
  365.                 }
  366.                 break;
  367.             }
  368.             break;
  369.  
  370.         }
  371.  
  372.     }
  373.  
  374.     } while( ok );
  375.  
  376.     AttaccaGadgets();
  377.  
  378.     IE.flags &= ~MOVE;
  379.  
  380.     return( gad );
  381. }
  382. ///
  383.  
  384. /// Copia Booleano
  385. BOOL CopiaBooleano( struct BooleanInfo *from, WORD x, WORD y )
  386. {
  387.     struct BooleanInfo *to;
  388.     BOOL                ret = FALSE;
  389.     struct TxtAttrNode *font;
  390.  
  391.     if( to = AllocObject( IE_BOOLEAN )) {
  392.  
  393.     CopyMem(( char * )from, ( char * )to, sizeof( struct BooleanInfo ));
  394.     AddTail((struct List *)&IE.win_info->wi_Gadgets, (struct Node *)to );
  395.  
  396.     to->b_GadgetText = &to->b_FrontPen;
  397.     to->b_flags2 &= ~G_ATTIVO;
  398.     to->b_Left   += x;
  399.     to->b_Top    += y;
  400.  
  401.     if( font = to->b_TextFont ) {
  402.         (ULONG)font -= 14;
  403.         font->txa_OpenCnt += 1;
  404.     }
  405.  
  406.     IE.win_info->wi_NumGads  += 1;
  407.     IE.win_info->wi_NumBools += 1;
  408.  
  409.     ret = TRUE;
  410.     }
  411.  
  412.     return( ret );
  413. }
  414. ///
  415.  
  416. /// Copia Gadgets
  417. BOOL CopiaGadMenued( void )
  418. {
  419.     struct GadgetInfo  *gad, *to;
  420.     struct GadgetScelta *gs, *gs2;
  421.     struct TxtAttrNode  *font;
  422.     WORD                x, y;
  423.     BOOL                ok = TRUE;
  424.     ULONG              *ptr;
  425.  
  426.  
  427.     if( TestAttivi() ) {
  428.  
  429.     gad = IE.win_info->wi_Gadgets.mlh_Head;
  430.     while(!( gad->g_flags2 & G_ATTIVO ))
  431.         gad = gad->g_Node.ln_Succ;
  432.  
  433.     x = 0;
  434.     y = 0;
  435.  
  436.     if( MuoviGadgets( gad, gad->g_Left, gad->g_Top, &x, &y, 0x68 )) {
  437.  
  438.         for( gad = IE.win_info->wi_Gadgets.mlh_Head; gad->g_Node.ln_Succ; gad = gad->g_Node.ln_Succ ) {
  439.         if(( gad->g_flags2 & G_ATTIVO ) && ( gad->g_Kind < MIN_IEX_ID )) {
  440.  
  441.             if( gad->g_Kind == BOOLEAN ) {
  442.  
  443.             ok = CopiaBooleano(( struct BooleanInfo * )gad, x, y );
  444.  
  445.             } else {
  446.  
  447.             if( to = AllocObject( IE_GADGET )) {
  448.  
  449.                 CopyMem(( char * )gad, (char *)to, sizeof( struct GadgetInfo ));
  450.                 AddTail(( struct List * )&IE.win_info->wi_Gadgets, (struct Node *)to );
  451.  
  452.                 IE.win_info->wi_NumGads += 1;
  453.  
  454.                 to->g_GadgetText = to->g_Titolo;
  455.                 to->g_flags2    &= ~G_ATTIVO;
  456.                 to->g_Left      += x;
  457.                 to->g_Top       += y;
  458.  
  459.                 if( font = to->g_Font )
  460.                 font->txa_OpenCnt += 1;
  461.  
  462.                 NewList( &to->g_Scelte );
  463.  
  464.                 if(( ptr = gad->g_ExtraMem ) && ( gad->g_Kind != MX_KIND ) && ( gad->g_Kind != CYCLE_KIND )){
  465.  
  466.                 (ULONG)ptr -= 4;
  467.  
  468.                 if( to->g_ExtraMem = AllocVec( *ptr, 0L )) {
  469.                     CopyMem((char *)gad->g_ExtraMem, (char *)to->g_ExtraMem, *ptr);
  470.                 } else {
  471.                     ok = FALSE;
  472.                 }
  473.                 } else {
  474.                 to->g_ExtraMem = NULL;
  475.                 }
  476.  
  477.                 for( gs = gad->g_Scelte.mlh_Head; gs->gs_Node.ln_Succ; gs = gs->gs_Node.ln_Succ ) {
  478.                 if( gs2 = AllocObject( IE_ITEM )) {
  479.  
  480.                     AddTail(( struct List * )&to->g_Scelte, (struct Node *)gs2);
  481.                     gs2->gs_Node.ln_Name = gs2->gs_Testo;
  482.                     strcpy( gs2->gs_Testo, gs->gs_Testo );
  483.  
  484.                 } else {
  485.                     DisplayBeep( Scr );
  486.                 }
  487.                 }
  488.  
  489.             } else {
  490.                 ok = FALSE;
  491.             }
  492.             }
  493.  
  494.             if(!( ok )) {
  495.             Stat( CatCompArray[ ERR_NOMEMORY ].cca_Str, FALSE, 0 );
  496.             return( TRUE );
  497.             }
  498.         }
  499.         }
  500.  
  501.         struct IEXNode *ex;
  502.         for( ex = IE.Expanders.mlh_Head; ex->Node.ln_Succ; ex = ex->Node.ln_Succ ) {
  503.         IEXBase = ex->Base;
  504.         if(!( IEX_Copy( ex->ID, &IE, x, y ))) {
  505.             Stat( CatCompArray[ ERR_NOMEMORY ].cca_Str, FALSE, 0 );
  506.             return( TRUE );
  507.         }
  508.         }
  509.  
  510.         Stat( CatCompArray[ MSG_DONE ].cca_Str, FALSE, 0 );
  511.         RifaiGadgets();
  512.         RinfrescaFinestra();
  513.         offx = offy = 0;
  514.         Coord();
  515.         IE.flags &= ~SALVATO;
  516.  
  517.     } else {
  518.         Stat( CatCompArray[ MSG_ABORTED ].cca_Str, FALSE, 0 );
  519.     }
  520.  
  521.     }
  522. }
  523. ///
  524.  
  525. /// Font Request
  526. struct TxtAttrNode *FontRequest( struct TextAttr *font, STRPTR titolo, ULONG titnum )
  527. {
  528.     struct TxtAttrNode *ret = NULL;
  529.     static struct TextAttr     def = { "topaz.font", 8, 0, 1 };
  530.     struct FontRequester *req;
  531.  
  532.     LockAllWindows();
  533.  
  534.     if( font ) {
  535.     def.ta_Name  = font->ta_Name;
  536.     def.ta_YSize = font->ta_YSize;
  537.     def.ta_Style = font->ta_Style;
  538.     def.ta_Flags = font->ta_Flags;
  539.     }
  540.  
  541.     if( LocaleBase ) {
  542.     titolo = GetCatalogStr( Catalog, titnum, titolo );
  543.     }
  544.  
  545.     if( req = AllocAslRequest( ASL_FontRequest, NULL )) {
  546.  
  547.     if( AslRequestTags( req,
  548.             ASLFO_TitleText,        titolo,
  549.             ASLFO_DoStyle,          TRUE,
  550.             ASLFO_MaxHeight,        300,
  551.             ASLFO_InitialHeight,    Scr->Height - 40,
  552.             ASLFO_InitialName,      def.ta_Name,
  553.             ASLFO_InitialSize,      def.ta_YSize,
  554.             ASLFO_InitialStyle,     def.ta_Style,
  555.             ASLFO_InitialFlags,     def.ta_Flags,
  556.             ASLFO_Window,           BackWnd,
  557.             TAG_END )) {
  558.  
  559.         ret = AggiungiFont( &req->fo_Attr );
  560.  
  561.     }
  562.  
  563.     FreeAslRequest( req );
  564.  
  565.     } else {
  566.     Stat( CatCompArray[ ERR_NOASL ].cca_Str, TRUE, 0 );
  567.     }
  568.  
  569.     UnlockAllWindows();
  570.     return( ret );
  571. }
  572. ///
  573.  
  574. /// Gadget Font
  575. BOOL GadFontMenued( void )
  576. {
  577.     struct GadgetInfo   *gad;
  578.     struct TxtAttrNode  *font;
  579.     struct TextAttr     *ta;
  580.  
  581.     if( TestAttivi() ) {
  582.  
  583.     gad = IE.win_info->wi_Gadgets.mlh_Head;
  584.     while(!( gad->g_flags2 & G_ATTIVO ))
  585.         gad = gad->g_Node.ln_Succ;
  586.  
  587.     if( gad->g_Kind >= MIN_IEX_ID ) {
  588.         struct IEXNode *ex;
  589.  
  590.         ex = IE.Expanders.mlh_Head;
  591.         while( ex->ID != gad->g_Kind )
  592.         ex = ex->Node.ln_Succ;
  593.  
  594.         if(!( ex->Base->UseFonts ))
  595.         return( TRUE );
  596.     }
  597.  
  598.     ta = gad->g_Font ? &gad->g_Font->txa_FontName : NULL;
  599.  
  600.     if( font = FontRequest( ta, CatCompArray[ ASL_GAD_FONT ].cca_Str, ASL_GAD_FONT )) {
  601.  
  602.         font->txa_OpenCnt -= 1;
  603.  
  604.         for( gad = IE.win_info->wi_Gadgets.mlh_Head; gad->g_Node.ln_Succ; gad = gad->g_Node.ln_Succ ) {
  605.         if( gad->g_flags2 & G_ATTIVO ) {
  606.  
  607.             BOOL ok = TRUE;
  608.  
  609.             if( gad->g_Kind >= MIN_IEX_ID ) {
  610.             struct IEXNode *ex2;
  611.  
  612.             ex2 = IE.Expanders.mlh_Head;
  613.             while( ex2->ID != gad->g_Kind )
  614.                 ex2 = ex2->Node.ln_Succ;
  615.  
  616.             ok = ex2->Base->UseFonts;
  617.             }
  618.  
  619.             if( ok ) {
  620.             EliminaFont( gad->g_Font );
  621.  
  622.             gad->g_Font = font;
  623.             font->txa_OpenCnt += 1;
  624.             }
  625.  
  626.             if( gad->g_Kind == BOOLEAN )
  627.             ((struct BooleanInfo *)gad)->b_TextFont = &font->txa_FontName;
  628.             else
  629.             if( gad->g_Kind < MIN_IEX_ID )
  630.                 gad->g_TextAttr = &font->txa_FontName;
  631.         }
  632.         }
  633.  
  634.         RifaiGadgets();
  635.         RinfrescaFinestra();
  636.         IE.flags &= ~SALVATO;
  637.     }
  638.     }
  639.  
  640.     return( TRUE );
  641. }
  642. ///
  643.  
  644. /// Ridimensiona gadgets
  645. BOOL Resizable( struct GadgetInfo *gad )
  646. {
  647.     BOOL    ret = TRUE;
  648.  
  649.     if( gad->g_Kind < MIN_IEX_ID ) {
  650.     if(!( gadgetxy_index[ gad->g_Kind ].Resize )) {
  651.         if( gad->g_Kind == MX_KIND ) {
  652.         ret = gad->g_Tags & 4;
  653.         } else {
  654.         ret = gad->g_Tags & 8;
  655.         }
  656.     }
  657.     } else {
  658.     struct IEXNode *ex;
  659.  
  660.     ex = IE.Expanders.mlh_Head;
  661.  
  662.     while( ex->ID != gad->g_Kind )
  663.         ex = ex->Node.ln_Succ;
  664.  
  665.     ret = ex->Base->Resizable;
  666.     }
  667.  
  668.     return( ret );
  669. }
  670.  
  671. BOOL ResizeGadgets( void )
  672. {
  673.     BOOL                ret = FALSE;
  674.     UWORD               code;
  675.     WORD                x, y, x1, y1, y2, x2;
  676.     struct GadgetInfo  *gad;
  677.  
  678.     if(!( Resizable( IE.gad_id )))
  679.     return( FALSE );
  680.  
  681.     code = CheckResizeGad();
  682.  
  683.     if( code != 0 ) {
  684.  
  685.     ret = TRUE;
  686.  
  687.     if( TraceGadRect( code, &x, &y )) {
  688.  
  689.         for( gad = IE.win_info->wi_Gadgets.mlh_Head; gad->g_Node.ln_Succ; gad = gad->g_Node.ln_Succ ) {
  690.         if( gad->g_flags2 & G_ATTIVO ) {
  691.  
  692.             if( Resizable( gad )) {
  693.  
  694.             x1 = gad->g_Left;
  695.             x2 = x1 + gad->g_Width - 1;
  696.             y1 = gad->g_Top;
  697.             y2 = y1 + gad->g_Height - 1;
  698.  
  699.             if( code >= 3 ) { // parte destra
  700.                 x2 += x;
  701.             } else {
  702.                 x1 += x;
  703.             }
  704.  
  705.             if(!( code & 1 )) { // parte inferiore
  706.                 y2 += y;
  707.             } else {
  708.                 y1 += y;
  709.             }
  710.  
  711.             if( x1 > x2 ) {
  712.                 x = x1;
  713.                 x1 = x2;
  714.                 x2 = x;
  715.             }
  716.  
  717.             if( y1 > y2 ) {
  718.                 y = y1;
  719.                 y1 = y2;
  720.                 y2 = y;
  721.             }
  722.  
  723.             gad->g_Left   = x1;
  724.             gad->g_Width  = x2 - x1 + 1;
  725.             gad->g_Top    = y1;
  726.             gad->g_Height = y2 - y1 + 1;
  727.  
  728.             CheckSize( gad );
  729.             }
  730.         }
  731.         }
  732.  
  733.         RifaiGadgets();
  734.         RinfrescaFinestra();
  735.         IE.flags &= ~(SALVATO | MOVE);
  736.         Stat( CatCompArray[ MSG_DONE ].cca_Str, FALSE, 0 );
  737.     }
  738.     }
  739.  
  740.     return( ret );
  741. }
  742.  
  743. UWORD CheckResizeGad( void )
  744. {
  745.     struct GadgetInfo  *gad;
  746.     WORD                xb, yb, x, y;
  747.     UWORD               code = 0;
  748.     BOOL                go = TRUE;
  749.  
  750.     x = clickx;
  751.     y = clicky;
  752.  
  753.     gad = IE.win_info->wi_Gadgets.mlh_Head;
  754.     while(( gad->g_Node.ln_Succ ) && ( go )) {
  755.  
  756.     xb = gad->g_Left;
  757.     yb = gad->g_Top;
  758.  
  759.     IE.gad_id = gad;
  760.  
  761.     if( x >= xb ) {
  762.         if( x <= xb + Q_W ) {           // fascia sinistra
  763.         if( y >= yb ) {             // fascia superiore
  764.             if( y <= yb + Q_H ) {   // angolo alto sinistra
  765.             offx = xb + gad->g_Width - 1;
  766.             offy = yb + gad->g_Height - 1;
  767.             code = 1;
  768.             go = FALSE;
  769.             } else {
  770.             yb += (gad->g_Height - 1);
  771.             if(( y <= yb ) && ( y >= yb - Q_H )) { // basso a sinistra
  772.                 offx = xb + gad->g_Width - 1;
  773.                 offy = gad->g_Top;
  774.                 code = 2;
  775.                 go = FALSE;
  776.             }
  777.             }
  778.         }
  779.         } else {
  780.         xb += (gad->g_Width - 1);
  781.         if(( x <= xb ) && ( x >= xb - Q_W )) {  // fascia destra
  782.             if( y >= yb ) {
  783.             if( y <= yb + Q_H ) {           // alto a destra
  784.                 offx = gad->g_Left;
  785.                 offy = yb + gad->g_Height - 1;
  786.                 code = 3;
  787.                 go = FALSE;
  788.             } else {
  789.                 yb += (gad->g_Height - 1);
  790.                 if(( y <= yb ) && ( y >= yb - Q_H )) { // basso a destra
  791.                 offx = gad->g_Left;
  792.                 offy = gad->g_Top;
  793.                 code = 4;
  794.                 go = FALSE;
  795.                 }
  796.             }
  797.             }
  798.         }
  799.         }
  800.     }
  801.  
  802.     gad = gad->g_Node.ln_Succ;
  803.     }
  804.  
  805.     return( code );
  806. }
  807.  
  808. BOOL TraceGadRect( UWORD code2, WORD *x, WORD *y )
  809. {
  810.     BOOL                    ok = TRUE, ret = FALSE;
  811.     struct IntuiMessage    *msg;
  812.     ULONG                   class;
  813.     int                     code;
  814.     struct Window          *wnd;
  815.  
  816.     *y = 0;
  817.     *x = 0;
  818.  
  819.     IE.win_active->Flags |= WFLG_RMBTRAP;
  820.     SetDrMd( IE.win_active->RPort, COMPLEMENT );
  821.  
  822.     do {
  823.  
  824.     WaitPort( IE.win_active->UserPort );
  825.  
  826.     while( msg = GT_GetIMsg( IE.win_active->UserPort )) {
  827.  
  828.         class = msg->Class;
  829.         code  = msg->Code;
  830.         wnd   = msg->IDCMPWindow;
  831.  
  832.         GT_ReplyIMsg( msg );
  833.  
  834.         switch( class ) {
  835.  
  836.         case IDCMP_REFRESHWINDOW:
  837.             GT_BeginRefresh( wnd );
  838.             GT_EndRefresh( wnd, TRUE );
  839.             break;
  840.  
  841.         case IDCMP_MOUSEBUTTONS:
  842.             switch( code ) {
  843.             case 0x69:
  844.                 ok = FALSE;
  845.                 Stat( CatCompArray[ MSG_ABORTED ].cca_Str, FALSE, 0 );
  846.                 break;
  847.  
  848.             case 0xE8:
  849.                 ok = FALSE;
  850.                 ret = TRUE;
  851.             }
  852.             break;
  853.  
  854.         case IDCMP_MOUSEMOVE:
  855.             RedrawResize( code2, *x, *y );
  856.             Coord();
  857.             *x = mousex - clickx;
  858.             *y = mousey - clicky;
  859.             RedrawResize( code2, *x, *y );
  860.             break;
  861.         }
  862.     }
  863.  
  864.     } while( ok );
  865.  
  866.     RedrawResize( code2, *x, *y );
  867.  
  868.     offx = offy = 0;
  869.     Coord();
  870.  
  871.     SetDrMd( IE.win_active->RPort, JAM1 );
  872.     IE.win_active->Flags &= ~WFLG_RMBTRAP;
  873.  
  874.     return( ret );
  875. }
  876.  
  877. void RedrawResize( UWORD code, WORD x, WORD y )
  878. {
  879.     struct GadgetInfo  *gad;
  880.     WORD                x1, x2, y1, y2;
  881.  
  882.     for( gad = IE.win_info->wi_Gadgets.mlh_Head; gad->g_Node.ln_Succ; gad = gad->g_Node.ln_Succ ) {
  883.     if( gad->g_flags2 & G_ATTIVO ) {
  884.  
  885.         if( Resizable( gad )) {
  886.  
  887.         x1 = gad->g_Left;
  888.         y1 = gad->g_Top;
  889.         x2 = x1 + gad->g_Width - 1;
  890.         y2 = y1 + gad->g_Height - 1;
  891.  
  892.         if( code >= 3 )
  893.             x2 += x;
  894.         else
  895.             x1 += x;
  896.  
  897.         if(!( code & 1 ))
  898.             y2 += y;
  899.         else
  900.             y1 += y;
  901.  
  902.         Rect( x1, y1, x2, y2 );
  903.         }
  904.     }
  905.     }
  906. }
  907. ///
  908.  
  909. /// Specifica dimensioni gadgets
  910. BOOL GadSizeMenued( void )
  911. {
  912.     struct GadgetInfo  *gad;
  913.  
  914.     LockAllWindows();
  915.     LayoutWindow( GadSizeWTags );
  916.  
  917.     for( gad = IE.win_info->wi_Gadgets.mlh_Head; gad->g_Node.ln_Succ; gad = gad->g_Node.ln_Succ ) {
  918.     if( gad->g_flags2 & G_ATTIVO ) {
  919.  
  920.         buffer = gad;
  921.  
  922.         if (!( OpenGadSizeWindow() )) {
  923.  
  924.         IntegerTag[1] = gad->g_Left;
  925.         GT_SetGadgetAttrsA( GadSizeGadgets[ GD_GS_X ], GadSizeWnd,
  926.                     NULL, (struct TagItem *)IntegerTag );
  927.         IntegerTag[1] = gad->g_Top;
  928.         GT_SetGadgetAttrsA( GadSizeGadgets[ GD_GS_Y ], GadSizeWnd,
  929.                     NULL, (struct TagItem *)IntegerTag );
  930.         IntegerTag[1] = gad->g_Width;
  931.         GT_SetGadgetAttrsA( GadSizeGadgets[ GD_GS_W ], GadSizeWnd,
  932.                     NULL, (struct TagItem *)IntegerTag );
  933.         IntegerTag[1] = gad->g_Height;
  934.         GT_SetGadgetAttrsA( GadSizeGadgets[ GD_GS_H ], GadSizeWnd,
  935.                     NULL, (struct TagItem *)IntegerTag );
  936.  
  937.         while( ReqHandle( GadSizeWnd, HandleGadSizeIDCMP ));
  938.  
  939.         }
  940.  
  941.         CloseGadSizeWindow();
  942.     }
  943.     }
  944.  
  945.     PostOpenWindow( GadSizeWTags );
  946.     UnlockAllWindows();
  947.  
  948.     return( TRUE );
  949. }
  950.  
  951. BOOL GadSizeVanillaKey( void )
  952. {
  953.     switch( GadSizeMsg.Code ) {
  954.     case 13:
  955.         return( GS_OkClicked() );
  956.     case 27:
  957.         return( GS_AnnullaClicked() );
  958.     }
  959.     return( TRUE );
  960. }
  961.  
  962. BOOL GS_OkKeyPressed( void )
  963. {
  964.     return( GS_OkClicked() );
  965. }
  966.  
  967. BOOL GS_OkClicked( void )
  968. {
  969.     (( struct GadgetInfo *)buffer )->g_Left   = GetNumber( GadSizeGadgets[ GD_GS_X ]);
  970.     (( struct GadgetInfo *)buffer )->g_Top    = GetNumber( GadSizeGadgets[ GD_GS_Y ]);
  971.     (( struct GadgetInfo *)buffer )->g_Width  = GetNumber( GadSizeGadgets[ GD_GS_W ]);
  972.     (( struct GadgetInfo *)buffer )->g_Height = GetNumber( GadSizeGadgets[ GD_GS_H ]);
  973.  
  974.     CheckSize(( struct GadgetInfo *)buffer );
  975.     RifaiGadgets();
  976.     RinfrescaFinestra();
  977.     IE.flags &= ~SALVATO;
  978.  
  979.     return( FALSE );
  980. }
  981.  
  982. BOOL GS_AnnullaKeyPressed( void )
  983. {
  984.     return( FALSE );
  985. }
  986.  
  987. BOOL GS_AnnullaClicked( void )
  988. {
  989.     return( FALSE );
  990. }
  991.  
  992. BOOL GS_XClicked( void )
  993. {
  994.     ActivateGadget( GadSizeGadgets[ GD_GS_Y ], GadSizeWnd, NULL );
  995.     return( TRUE );
  996. }
  997.  
  998. BOOL GS_YClicked( void )
  999. {
  1000.     ActivateGadget( GadSizeGadgets[ GD_GS_W ], GadSizeWnd, NULL );
  1001.     return( TRUE );
  1002. }
  1003.  
  1004. BOOL GS_WClicked( void )
  1005. {
  1006.     ActivateGadget( GadSizeGadgets[ GD_GS_H ], GadSizeWnd, NULL );
  1007.     return( TRUE );
  1008. }
  1009.  
  1010. BOOL GS_HClicked( void )
  1011. {
  1012.     return( TRUE );
  1013. }
  1014. ///
  1015.  
  1016. /// Seleziona tutti
  1017. BOOL SelAllMenued( void )
  1018. {
  1019.     struct GadgetInfo *gad;
  1020.  
  1021.     for( gad = IE.win_info->wi_Gadgets.mlh_Head; gad->g_Node.ln_Succ; gad = gad->g_Node.ln_Succ ) {
  1022.  
  1023.     BOOL can = TRUE;
  1024.  
  1025.     if( gad->g_Kind >= MIN_IEX_ID ) {
  1026.         struct IEXNode *ex;
  1027.  
  1028.         ex = IE.Expanders.mlh_Head;
  1029.         while( ex->ID != gad->g_Kind )
  1030.         ex = ex->Node.ln_Succ;
  1031.  
  1032.         if( ex->Base->Movable || ex->Base->Resizable )
  1033.         can = TRUE;
  1034.     }
  1035.  
  1036.     if( can )
  1037.         gad->g_flags2 |= G_ATTIVO;
  1038.     }
  1039.  
  1040.     RinfrescaFinestra();
  1041.  
  1042.     return( TRUE );
  1043. }
  1044. ///
  1045.  
  1046. /// Disattiva tutti
  1047. void DisattivaTuttiGad( void )
  1048. {
  1049.     struct GadgetInfo *gad;
  1050.  
  1051.     ContornoGadgets( FALSE );
  1052.  
  1053.     for( gad = IE.win_info->wi_Gadgets.mlh_Head; gad->g_Node.ln_Succ; gad = gad->g_Node.ln_Succ ) {
  1054.     gad->g_flags2 &= ~G_ATTIVO;
  1055.     }
  1056.  
  1057. }
  1058. ///
  1059.  
  1060. /// Clonazioni
  1061. BOOL ClonaBothMenued( void )
  1062. {
  1063.     struct GadgetInfo *from, *to;
  1064.  
  1065.     if( TestAttivi() ) {
  1066.     if( from = GetGad() ) {
  1067.         for( to = IE.win_info->wi_Gadgets.mlh_Head; to->g_Node.ln_Succ; to = to->g_Node.ln_Succ ) {
  1068.         if( to->g_flags2 & G_ATTIVO ) {
  1069.             if( gadgetxy_index[ to->g_Kind ].Resize ) {
  1070.             to->g_Width  = from->g_Width;
  1071.             to->g_Height = from->g_Height;
  1072.             }
  1073.         }
  1074.         }
  1075.     }
  1076.     }
  1077.  
  1078.     RifaiGadgets();
  1079.     RinfrescaFinestra();
  1080.     IE.flags &= ~SALVATO;
  1081.  
  1082.     return( TRUE );
  1083. }
  1084.  
  1085. BOOL ClonaWMenued( void )
  1086. {
  1087.     struct GadgetInfo *from, *to;
  1088.  
  1089.     if( TestAttivi() ) {
  1090.     if( from = GetGad() ) {
  1091.         for( to = IE.win_info->wi_Gadgets.mlh_Head; to->g_Node.ln_Succ; to = to->g_Node.ln_Succ ) {
  1092.         if( to->g_flags2 & G_ATTIVO ) {
  1093.             if( gadgetxy_index[ to->g_Kind ].Resize ) {
  1094.             to->g_Width  = from->g_Width;
  1095.             }
  1096.         }
  1097.         }
  1098.     }
  1099.     }
  1100.  
  1101.     RifaiGadgets();
  1102.     RinfrescaFinestra();
  1103.     IE.flags &= ~SALVATO;
  1104.  
  1105.     return( TRUE );
  1106. }
  1107.  
  1108. BOOL ClonaHMenued( void )
  1109. {
  1110.     struct GadgetInfo *from, *to;
  1111.  
  1112.     if( TestAttivi() ) {
  1113.     if( from = GetGad() ) {
  1114.         for( to = IE.win_info->wi_Gadgets.mlh_Head; to->g_Node.ln_Succ; to = to->g_Node.ln_Succ ) {
  1115.         if( to->g_flags2 & G_ATTIVO ) {
  1116.             if( gadgetxy_index[ to->g_Kind ].Resize ) {
  1117.             to->g_Height = from->g_Height;
  1118.             }
  1119.         }
  1120.         }
  1121.     }
  1122.     }
  1123.  
  1124.     RifaiGadgets();
  1125.     RinfrescaFinestra();
  1126.     IE.flags &= ~SALVATO;
  1127.  
  1128.     return( TRUE );
  1129. }
  1130. ///
  1131.  
  1132. /// Allineamenti
  1133. BOOL AlignDownMenued( void )
  1134. {
  1135.     struct GadgetInfo  *to, *from;
  1136.     WORD                y;
  1137.  
  1138.     if( TestAttivi() ) {
  1139.     if( from = GetGad() ) {
  1140.  
  1141.         y = from->g_Top + from->g_Height;
  1142.  
  1143.         for( to = IE.win_info->wi_Gadgets.mlh_Head; to->g_Node.ln_Succ; to = to->g_Node.ln_Succ ) {
  1144.         if( to->g_flags2 & G_ATTIVO ) {
  1145.             to->g_Top = y - to->g_Height;
  1146.         }
  1147.         }
  1148.  
  1149.         RifaiGadgets();
  1150.         RinfrescaFinestra();
  1151.         IE.flags &= ~SALVATO;
  1152.  
  1153.         Stat( CatCompArray[ MSG_GAD_ALIGNED ].cca_Str, FALSE, 0 );
  1154.     }
  1155.     }
  1156.  
  1157.     return( TRUE );
  1158. }
  1159.  
  1160. BOOL AlignUpMenued( void )
  1161. {
  1162.     struct GadgetInfo  *to, *from;
  1163.  
  1164.     if( TestAttivi() ) {
  1165.     if( from = GetGad() ) {
  1166.  
  1167.         for( to = IE.win_info->wi_Gadgets.mlh_Head; to->g_Node.ln_Succ; to = to->g_Node.ln_Succ ) {
  1168.         if( to->g_flags2 & G_ATTIVO ) {
  1169.             to->g_Top = from->g_Top;
  1170.         }
  1171.         }
  1172.  
  1173.         RifaiGadgets();
  1174.         RinfrescaFinestra();
  1175.         IE.flags &= ~SALVATO;
  1176.  
  1177.         Stat( CatCompArray[ MSG_GAD_ALIGNED ].cca_Str, FALSE, 0 );
  1178.     }
  1179.     }
  1180.  
  1181.     return( TRUE );
  1182. }
  1183.  
  1184. BOOL AlignRightMenued( void )
  1185. {
  1186.     struct GadgetInfo  *to, *from;
  1187.     WORD                x;
  1188.  
  1189.     if( TestAttivi() ) {
  1190.     if( from = GetGad() ) {
  1191.  
  1192.         x = from->g_Left + from->g_Width;
  1193.  
  1194.         for( to = IE.win_info->wi_Gadgets.mlh_Head; to->g_Node.ln_Succ; to = to->g_Node.ln_Succ ) {
  1195.         if( to->g_flags2 & G_ATTIVO ) {
  1196.             to->g_Left = x - to->g_Width;
  1197.         }
  1198.         }
  1199.  
  1200.         RifaiGadgets();
  1201.         RinfrescaFinestra();
  1202.         IE.flags &= ~SALVATO;
  1203.  
  1204.         Stat( CatCompArray[ MSG_GAD_ALIGNED ].cca_Str, FALSE, 0 );
  1205.     }
  1206.     }
  1207.  
  1208.     return( TRUE );
  1209. }
  1210.  
  1211. BOOL AlignLeftMenued( void )
  1212. {
  1213.     struct GadgetInfo  *to, *from;
  1214.  
  1215.     if( TestAttivi() ) {
  1216.     if( from = GetGad() ) {
  1217.  
  1218.         for( to = IE.win_info->wi_Gadgets.mlh_Head; to->g_Node.ln_Succ; to = to->g_Node.ln_Succ ) {
  1219.         if( to->g_flags2 & G_ATTIVO ) {
  1220.             to->g_Left = from->g_Left;
  1221.         }
  1222.         }
  1223.  
  1224.         RifaiGadgets();
  1225.         RinfrescaFinestra();
  1226.         IE.flags &= ~SALVATO;
  1227.  
  1228.         Stat( CatCompArray[ MSG_GAD_ALIGNED ].cca_Str, FALSE, 0 );
  1229.     }
  1230.     }
  1231.  
  1232.     return( TRUE );
  1233. }
  1234. ///
  1235.  
  1236. /// Muovi gadgets
  1237. void PosizioneGadgets( WORD x, WORD y )
  1238. {
  1239.     BOOL                ret;
  1240.     struct GadgetInfo  *gad;
  1241.  
  1242.     ret = MuoviGadgets( IE.gad_id, mousex - x, mousey - y, &x, &y, 0xE8 );
  1243.     IE.flags &= ~MOVE;
  1244.  
  1245.     if( ret ) {
  1246.  
  1247.     for( gad = IE.win_info->wi_Gadgets.mlh_Head; gad->g_Node.ln_Succ; gad = gad->g_Node.ln_Succ ) {
  1248.         if( gad->g_flags2 & G_ATTIVO ) {
  1249.         gad->g_Left += x;
  1250.         gad->g_Top  += y;
  1251.         }
  1252.     }
  1253.  
  1254.     RifaiGadgets();
  1255.     RinfrescaFinestra();
  1256.     offx = offy = 0;
  1257.     Coord();
  1258.     IE.flags &= ~SALVATO;
  1259.     Stat( CatCompArray[ MSG_DONE ].cca_Str, FALSE, 0 );
  1260.     }
  1261. }
  1262.  
  1263. BOOL MuoviGadgets( struct GadgetInfo *rif, WORD x, WORD y, WORD *ox, WORD *oy, UWORD EndCode )
  1264. {
  1265.     WORD                    x3, y3, x4, y4;
  1266.     BOOL                    ret = FALSE, ok = TRUE;
  1267.     struct IntuiMessage    *msg;
  1268.     int                     code;
  1269.     ULONG                   class;
  1270.     struct Window          *wnd;
  1271.     struct GadgetInfo      *gad;
  1272.  
  1273.     offx = x - rif->g_Left;
  1274.     offy = y - rif->g_Top;
  1275.  
  1276.     IE.win_active->Flags |= WFLG_RMBTRAP;
  1277.     SetDrMd( IE.win_active->RPort, COMPLEMENT );
  1278.  
  1279.     StaccaGadgets();
  1280.  
  1281.     for( gad = IE.win_info->wi_Gadgets.mlh_Head; gad->g_Node.ln_Succ; gad = gad->g_Node.ln_Succ ) {
  1282.     if( gad->g_flags2 & G_ATTIVO ) {
  1283.         x4 = gad->g_Left + *ox;
  1284.         y4 = gad->g_Top  + *oy;
  1285.         Rect( x4, y4, x4 + gad->g_Width - 1, y4 + gad->g_Height - 1 );
  1286.     }
  1287.     }
  1288.  
  1289.     do {
  1290.  
  1291.     WaitPort( IE.win_active->UserPort );
  1292.  
  1293.     while( msg = GT_GetIMsg( IE.win_active->UserPort )) {
  1294.  
  1295.         class = msg->Class;
  1296.         code  = msg->Code;
  1297.         wnd   = msg->IAddress;
  1298.  
  1299.         GT_ReplyIMsg( msg );
  1300.  
  1301.         if( wnd == IE.win_active ) {
  1302.  
  1303.         switch( class ) {
  1304.  
  1305.             case IDCMP_MOUSEBUTTONS:
  1306.             if( code == EndCode ) {
  1307.                 ok = FALSE;
  1308.                 ret = TRUE;
  1309.             } else {
  1310.                 if( code == 0x69 ) {
  1311.                 ok = FALSE;
  1312.                 Stat( CatCompArray[ MSG_ABORTED ].cca_Str, FALSE, 0 );
  1313.                 }
  1314.             }
  1315.             break;
  1316.  
  1317.             case IDCMP_MOUSEMOVE:
  1318.             Coord();
  1319.             x3 = wnd->MouseX - x;
  1320.             y3 = wnd->MouseY - y;
  1321.  
  1322.             for( gad = IE.win_info->wi_Gadgets.mlh_Head; gad->g_Node.ln_Succ; gad = gad->g_Node.ln_Succ ) {
  1323.                 if( gad->g_flags2 & G_ATTIVO ) {
  1324.                 x4 = gad->g_Left + *ox;
  1325.                 y4 = gad->g_Top  + *oy;
  1326.                 Rect( x4, y4, x4 + gad->g_Width - 1, y4 + gad->g_Height - 1 );
  1327.                 }
  1328.             }
  1329.  
  1330.             *ox = x3;
  1331.             *oy = y3;
  1332.  
  1333.             for( gad = IE.win_info->wi_Gadgets.mlh_Head; gad->g_Node.ln_Succ; gad = gad->g_Node.ln_Succ ) {
  1334.                 if( gad->g_flags2 & G_ATTIVO ) {
  1335.                 x4 = gad->g_Left + *ox;
  1336.                 y4 = gad->g_Top  + *oy;
  1337.                 Rect( x4, y4, x4 + gad->g_Width - 1, y4 + gad->g_Height - 1 );
  1338.                 }
  1339.             }
  1340.             break;
  1341.         }
  1342.         }
  1343.  
  1344.     }
  1345.  
  1346.     } while( ok );
  1347.  
  1348.     for( gad = IE.win_info->wi_Gadgets.mlh_Head; gad->g_Node.ln_Succ; gad = gad->g_Node.ln_Succ ) {
  1349.     if( gad->g_flags2 & G_ATTIVO ) {
  1350.         x4 = gad->g_Left + *ox;
  1351.         y4 = gad->g_Top  + *oy;
  1352.         Rect( x4, y4, x4 + gad->g_Width - 1, y4 + gad->g_Height - 1 );
  1353.     }
  1354.     }
  1355.  
  1356.     AttaccaGadgets();
  1357.  
  1358.     SetDrMd( IE.win_active->RPort, JAM1 );
  1359.     IE.win_active->Flags &= ~WFLG_RMBTRAP;
  1360.  
  1361.     return( ret );
  1362. }
  1363. ///
  1364.  
  1365. /// Rinfresca Finestra
  1366. void RinfrescaFinestra( void )
  1367. {
  1368.     struct BevelBoxNode *box;
  1369.     struct WndImages    *img;
  1370.     struct ITextNode    *txt;
  1371.     struct IEXNode      *ex;
  1372.     UBYTE                oldmp;
  1373.  
  1374.     if( IE.win_active && IE.win_info ) {
  1375.  
  1376.     StaccaGadgets();
  1377.  
  1378.     ContornoGadgets( FALSE );
  1379.  
  1380.     EraseRect( IE.win_active->RPort,
  1381.            IE.win_active->BorderLeft,
  1382.            IE.win_active->BorderTop,
  1383.            IE.win_active->Width  - IE.win_active->BorderRight,
  1384.            IE.win_active->Height - IE.win_active->BorderBottom );
  1385.  
  1386.     RefreshWindowFrame( IE.win_active );
  1387.  
  1388.     for( ex = IE.Expanders.mlh_Head; ex->Node.ln_Succ && ex->Base->Node.ln_Pri < 0; ex = ex->Node.ln_Succ ) {
  1389.         struct Expander *IEXBase;
  1390.         IEXBase = ex->Base;
  1391.         IEX_Refresh( ex->ID, &IE );
  1392.     }
  1393.  
  1394.     for( box = IE.win_info->wi_Boxes.mlh_Head; box->bb_Next; box = box->bb_Next ) {
  1395.  
  1396.         box->bb_VisualInfo = VisualInfo;
  1397.  
  1398.         DrawBevelBoxA( IE.win_active->RPort,
  1399.                box->bb_Left,
  1400.                box->bb_Top,
  1401.                box->bb_Width,
  1402.                box->bb_Height,
  1403.                (struct TagItem *)&box->bb_VITag );
  1404.     }
  1405.  
  1406.     if( IE.win_info->wi_NumImages ) {
  1407.         img = IE.win_info->wi_Images.mlh_Head;
  1408.         DrawImage( IE.win_active->RPort, (struct Image *)&img->wim_Left, 0, 0 );
  1409.     }
  1410.  
  1411.     if( IE.win_info->wi_NumTexts ) {
  1412.         txt = IE.win_info->wi_ITexts.mlh_Head;
  1413.         PrintIText( IE.win_active->RPort, (struct IntuiText *)&txt->itn_FrontPen, 0, 0 );
  1414.     }
  1415.  
  1416.     ex = IE.Expanders.mlh_Head;
  1417.     while( ex->Node.ln_Succ )
  1418.         if( ex->Base->Node.ln_Pri >= 0 )
  1419.         break;
  1420.         else
  1421.         ex = ex->Node.ln_Succ;
  1422.  
  1423.     for( ; ex->Node.ln_Succ; ex = ex->Node.ln_Succ ) {
  1424.         struct Expander *IEXBase;
  1425.         IEXBase = ex->Base;
  1426.         IEX_Refresh( ex->ID, &IE );
  1427.     }
  1428.  
  1429.     oldmp = IE.mainprefs;
  1430.  
  1431.     IE.mainprefs &= ~STACCATI;
  1432.     AttaccaGadgets();
  1433.  
  1434.     ContornoGadgets( TRUE );
  1435.  
  1436.     if( oldmp & STACCATI )
  1437.         StaccaGadgets();
  1438.  
  1439.     IE.mainprefs = oldmp;
  1440.     }
  1441. }
  1442. ///
  1443.  
  1444. /// Attiva Gadgets
  1445. void AttivaGadgets( void )
  1446. {
  1447.     struct IntuiMessage *msg;
  1448.     struct RastPort     *rport;
  1449.     struct Window       *wnd;
  1450.     BOOL                 ok = TRUE, go = FALSE;
  1451.     ULONG                class;
  1452.     int                  code;
  1453.  
  1454.     clickx = lastx = IE.win_active->MouseX;
  1455.     clicky = lasty = IE.win_active->MouseY;
  1456.  
  1457.     if(!( AttivaUno( clickx, clicky ) )) {
  1458.  
  1459.     rport = IE.win_active->RPort;
  1460.  
  1461.     SetDrMd( rport, COMPLEMENT );
  1462.  
  1463.     rport->LinePtrn = 0xFF00;
  1464.  
  1465.     IE.win_active->Flags |= WFLG_RMBTRAP;
  1466.  
  1467.     Stat( CatCompArray[ MSG_SELECT ].cca_Str, FALSE, 0 );
  1468.  
  1469.     do {
  1470.  
  1471.         WaitPort( IE.win_active->UserPort );
  1472.  
  1473.         while( msg = GT_GetIMsg( IE.win_active->UserPort )) {
  1474.  
  1475.         class = msg->Class;
  1476.         code  = msg->Code;
  1477.         wnd   = msg->IDCMPWindow;
  1478.  
  1479.         GT_ReplyIMsg( msg );
  1480.  
  1481.         if( IE.win_active == wnd ) {
  1482.             switch( class ) {
  1483.  
  1484.             case IDCMP_INTUITICKS:
  1485.                 Rect( clickx, clicky, lastx, lasty );
  1486.                 code = rport->LinePtrn >> 3;
  1487.                 rport->LinePtrn = code | (( rport->LinePtrn % 8 ) << 13 );
  1488.                 Rect( clickx, clicky, lastx, lasty );
  1489.                 break;
  1490.  
  1491.             case IDCMP_REFRESHWINDOW:
  1492.                 GT_BeginRefresh( wnd );
  1493.                 GT_EndRefresh( wnd, TRUE );
  1494.                 break;
  1495.  
  1496.             case IDCMP_MOUSEBUTTONS:
  1497.                 switch( code ) {
  1498.                 case 0xE8:
  1499.                     go = TRUE;
  1500.                     ok = FALSE;
  1501.                     break;
  1502.                 case 0x69:
  1503.                     ok = FALSE;
  1504.                     Stat( CatCompArray[ MSG_ABORTED ].cca_Str, FALSE, 0 );
  1505.                     break;
  1506.                 }
  1507.                 break;
  1508.  
  1509.             case IDCMP_MOUSEMOVE:
  1510.                 Coord();
  1511.                 Rect( clickx, clicky, lastx, lasty );
  1512.                 lastx = ( wnd->MouseX >= 0 ) ? wnd->MouseX : 0;
  1513.                 lasty = ( wnd->MouseY >= 0 ) ? wnd->MouseY : 0;
  1514.                 Rect( clickx, clicky, lastx, lasty );
  1515.                 break;
  1516.             }
  1517.         }
  1518.         }
  1519.  
  1520.     } while( ok );
  1521.  
  1522.     Rect( clickx, clicky, lastx, lasty );
  1523.  
  1524.     if( go ) {
  1525.  
  1526.         if( clickx > lastx ) {
  1527.         code = clickx;
  1528.         clickx = lastx;
  1529.         lastx = code;
  1530.         }
  1531.  
  1532.         if( clicky > lasty ) {
  1533.         code = clicky;
  1534.         clicky = lasty;
  1535.         lasty = code;
  1536.         }
  1537.  
  1538.         Attiva( clickx, clicky, lastx, lasty );
  1539.  
  1540.         Stat( ok_txt+1, FALSE, 0 );
  1541.     }
  1542.  
  1543.     IE.win_active->Flags &= ~WFLG_RMBTRAP;
  1544.     SetDrMd( rport, JAM1 );
  1545.     rport->LinePtrn = 0xFFFF;
  1546.  
  1547.     } else {
  1548.     IE.flags |= MOVE;
  1549.     }
  1550.  
  1551.     ContornoGadgets( TRUE );
  1552. }
  1553.  
  1554. BOOL Attiva( WORD x, WORD y, WORD x2, WORD y2 )
  1555. {
  1556.     BOOL                ret = FALSE, can;
  1557.     struct GadgetInfo  *gad;
  1558.  
  1559.     for( gad = IE.win_info->wi_Gadgets.mlh_Head; gad->g_Node.ln_Succ; gad = gad->g_Node.ln_Succ ) {
  1560.  
  1561.     can = FALSE;
  1562.  
  1563.     if( gad->g_Kind < MIN_IEX_ID )
  1564.         can = TRUE;
  1565.     else {
  1566.         struct IEXNode *ex;
  1567.  
  1568.         ex = IE.Expanders.mlh_Head;
  1569.         while( ex->ID != gad->g_Kind )
  1570.         ex = ex->Node.ln_Succ;
  1571.  
  1572.         if( ex->Base->Movable || ex->Base->Resizable )
  1573.         can = TRUE;
  1574.     }
  1575.  
  1576.     if(( can ) && (( x2 >= gad->g_Left ) && ( x < gad->g_Left + gad->g_Width ) && ( y2 >= gad->g_Top ) && ( y < gad->g_Top + gad->g_Height ))) {
  1577.         gad->g_flags2 |= G_ATTIVO;
  1578.         IE.gad_id = gad;
  1579.         ret = TRUE;
  1580.     }
  1581.  
  1582.     }
  1583.  
  1584.     return( ret );
  1585. }
  1586.  
  1587. BOOL AttivaUno( WORD x, WORD y )
  1588. {
  1589.     BOOL                ret = FALSE, can;
  1590.     struct GadgetInfo  *gad;
  1591.  
  1592.     for( gad = IE.win_info->wi_Gadgets.mlh_Head; gad->g_Node.ln_Succ; gad = gad->g_Node.ln_Succ ) {
  1593.  
  1594.     can = FALSE;
  1595.  
  1596.     if( gad->g_Kind < MIN_IEX_ID )
  1597.         can = TRUE;
  1598.     else {
  1599.         struct IEXNode *ex;
  1600.  
  1601.         ex = IE.Expanders.mlh_Head;
  1602.         while( ex->ID != gad->g_Kind )
  1603.         ex = ex->Node.ln_Succ;
  1604.  
  1605.         if( ex->Base->Movable || ex->Base->Resizable )
  1606.         can = TRUE;
  1607.     }
  1608.  
  1609.     if(( can ) && (( x >= gad->g_Left ) && ( x < gad->g_Left + gad->g_Width ) && ( y >= gad->g_Top ) && ( y < gad->g_Top + gad->g_Height ))) {
  1610.         gad->g_flags2 |= G_WAS_ACTIVE;
  1611.         ret = TRUE;
  1612.     }
  1613.     }
  1614.  
  1615.     if( ret ) {
  1616.     ULONG               area = 0xffffffff, area2;
  1617.  
  1618.     for( gad = IE.win_info->wi_Gadgets.mlh_Head; gad->g_Node.ln_Succ; gad = gad->g_Node.ln_Succ ) {
  1619.         if( gad->g_flags2 & G_WAS_ACTIVE ) {
  1620.         gad->g_flags2 &= ~G_WAS_ACTIVE;
  1621.  
  1622.         area2 = gad->g_Width * gad->g_Height;
  1623.  
  1624.         if( area2 < area ) {
  1625.             IE.gad_id = gad;
  1626.             area = area2;
  1627.         }
  1628.         }
  1629.     }
  1630.  
  1631.     IE.gad_id->g_flags2 |= G_ATTIVO;
  1632.     }
  1633.  
  1634.     return( ret );
  1635. }
  1636. ///
  1637.  
  1638. /// Contorno gadgets
  1639. void ContornoGadgets( BOOL what )
  1640. {
  1641.     struct GadgetInfo *gad;
  1642.  
  1643.     SetDrMd( IE.win_active->RPort, COMPLEMENT );
  1644.  
  1645.     for( gad = IE.win_info->wi_Gadgets.mlh_Head; gad->g_Node.ln_Succ; gad = gad->g_Node.ln_Succ ) {
  1646.     if( what ) {
  1647.         if( gad->g_flags2 & G_ATTIVO ) {
  1648.         if(!( gad->g_flags2 & G_CONTORNO )) {
  1649.             gad->g_flags2 |= G_CONTORNO;
  1650.             DisegnaContorno( gad->g_Left, gad->g_Top, gad->g_Width, gad->g_Height );
  1651.         }
  1652.         }
  1653.     } else {
  1654.         if( gad->g_flags2 & G_CONTORNO ) {
  1655.         gad->g_flags2 &= ~G_CONTORNO;
  1656.         DisegnaContorno( gad->g_Left, gad->g_Top, gad->g_Width, gad->g_Height );
  1657.         }
  1658.     }
  1659.     }
  1660.  
  1661.     SetDrMd( IE.win_active->RPort, JAM1 );
  1662. }
  1663. ///
  1664.  
  1665. /// MenuGadget Disattiva/Attiva
  1666. void MenuGadgetDisattiva( void )
  1667. {
  1668.     int cnt;
  1669.  
  1670.     for( cnt = 0; cnt < GADMENU_NUM; cnt++ )
  1671.     OffMenu( BackWnd, menugad_on[ cnt ]);
  1672.  
  1673.     if( ToolsWnd )
  1674.     OffGadget( &RemGadgetGadget, ToolsWnd, NULL );
  1675. }
  1676.  
  1677. void MenuGadgetAttiva( void )
  1678. {
  1679.     int cnt;
  1680.  
  1681.     for( cnt = 0; cnt < GADMENU_NUM; cnt++ )
  1682.     OnMenu( BackWnd, menugad_on[ cnt ]);
  1683.  
  1684.     if( ToolsWnd )
  1685.     OnGadget( &RemGadgetGadget, ToolsWnd, NULL );
  1686. }
  1687. ///
  1688.  
  1689. /// Gadget Tags
  1690. BOOL GadTagsMenued( void )
  1691. {
  1692.     struct GadgetInfo  *gad;
  1693.     BOOL                change = FALSE;
  1694.  
  1695.     LockAllWindows();
  1696.  
  1697.     for( gad = IE.win_info->wi_Gadgets.mlh_Head; gad->g_Node.ln_Succ; gad = gad->g_Node.ln_Succ ) {
  1698.     if( gad->g_flags2 & G_ATTIVO ) {
  1699.         if( gad->g_Kind < MIN_IEX_ID ) {
  1700.         void    ( *func )( struct GadgetInfo * );
  1701.         BOOL    key;
  1702.  
  1703.         func = modifica_index[ gad->g_Kind ];
  1704.  
  1705.         do {
  1706.             ( *func )( gad );
  1707.  
  1708.             key = FALSE;
  1709.  
  1710.             if( buffer ) {
  1711.  
  1712.             gad->g_Key = '\0';
  1713.  
  1714.             if( gad->g_Tags & 1 ) {
  1715.                 UBYTE  *ptr, ch;
  1716.  
  1717.                 ptr = gad->g_Titolo;
  1718.  
  1719.                 do {
  1720.                 ch = *ptr++;
  1721.                 } while(( ch != '_' ) && ( ch != '\0' ));
  1722.  
  1723.                 if( ch ) {
  1724.                 gad->g_Key = *ptr;
  1725.                 IE.win_info->wi_NumKeys += 1;
  1726.                 }
  1727.             }
  1728.  
  1729.             if( key = CheckActivationKey( IE.win_info, gad ))
  1730.                 Stat( CatCompArray[ ERR_DUPLICATE_KEY ].cca_Str, TRUE, 0 );
  1731.             }
  1732.  
  1733.         } while( key );
  1734.  
  1735.         change = TRUE;
  1736.  
  1737.         } else if( gad->g_Node.ln_Type == IEX_BOOPSI_KIND )
  1738.         change = BoopsiEditor(( struct BOOPSIInfo * )gad );
  1739.     }
  1740.     }
  1741.  
  1742.     struct IEXNode  *ex;
  1743.     for( ex = IE.Expanders.mlh_Head; ex->Node.ln_Succ; ex = ex->Node.ln_Succ ) {
  1744.     struct Expander    *IEXBase;
  1745.     IEXBase = ex->Base;
  1746.     if( IEXBase->Kind != IEX_BOOPSI_KIND ) {
  1747.         if( IEX_Edit( ex->ID, &IE ))
  1748.         change = TRUE;
  1749.     }
  1750.     }
  1751.  
  1752.     if( change ) {
  1753.  
  1754.     RifaiGadgets();
  1755.     RinfrescaFinestra();
  1756.     Stat( CatCompArray[ MSG_DONE ].cca_Str, FALSE, 0 );
  1757.     IE.flags &= ~SALVATO;
  1758.     }
  1759.  
  1760.     UnlockAllWindows();
  1761.  
  1762.     return( TRUE );
  1763. }
  1764. ///
  1765.  
  1766. /// Aggiungi Gadget
  1767. BOOL AddGadClicked( void )
  1768. {
  1769.     return( AddGadMenued() );
  1770. }
  1771.  
  1772. BOOL AddGadMenued( void )
  1773. {
  1774.     int                 num;
  1775.     struct GadgetInfo  *gad;
  1776.     WORD                x1, x2, y1, y2, swap;
  1777.     UBYTE              *ptr, ch;
  1778.     void                ( *func )( struct GadgetInfo * );
  1779.  
  1780.  
  1781.     if( ApriListaFin( CatCompArray[ REQ_GADTYPE ].cca_Str, REQ_GADTYPE, &listgadgets )) {
  1782.  
  1783.     num = GestisciListaFin( EXIT, 12 );
  1784.  
  1785.     ChiudiListaFin();
  1786.  
  1787.     if( num >= 0 ) {
  1788.  
  1789.         RinfrescaFinestra();
  1790.  
  1791.         if( num == ( BOOLEAN - 2 )) {
  1792.         AggiungiBooleano();
  1793.         } else {
  1794.         if( num >= ( MIN_IEX_ID - 2 )) {
  1795.             AddObject( num );
  1796.         } else {
  1797.             if( gad = AllocObject( IE_GADGET )) {
  1798.  
  1799.             AddTail((struct List *)&IE.win_info->wi_Gadgets, (struct Node *)gad );
  1800.  
  1801.             gad->g_Kind = num + 1;
  1802.             if( gad->g_Kind > SCROLLER_KIND )
  1803.                 gad->g_Kind += 1;
  1804.  
  1805.             if(( gad->g_Kind == STRING_KIND ) || ( gad->g_Kind == TEXT_KIND )) {
  1806.                 if(!( gad->g_ExtraMem = AllocVec( 120, MEMF_CLEAR ))) {
  1807.                 Stat( CatCompArray[ ERR_NOMEMORY ].cca_Str, TRUE, 0 );
  1808.                 Remove((struct Node *)gad );
  1809.                 FreeObject( gad, IE_GADGET );
  1810.                 return( TRUE );
  1811.                 }
  1812.             }
  1813.  
  1814.             Stat( CatCompArray[ MSG_DRAW_GAD ].cca_Str, FALSE, 0 );
  1815.  
  1816.             ActivateWindow( IE.win_active );
  1817.  
  1818.             IE.flags &= ~RECTFIXED;
  1819.  
  1820.             if(!( gadgetxy_index[ gad->g_Kind ].Resize ))
  1821.                 IE.flags |= RECTFIXED;
  1822.  
  1823.  
  1824.             DrawRect( gadgetxy_index[ gad->g_Kind ].Width, gadgetxy_index[ gad->g_Kind ].Height );
  1825.  
  1826.             offx = offy = 0;
  1827.             Coord();
  1828.  
  1829.             x1 = clickx;
  1830.             x2 = lastx;
  1831.             y1 = clicky;
  1832.             y2 = lasty;
  1833.  
  1834.             if( x2 < x1 ) {
  1835.                 swap = x1;
  1836.                 x1 = x2;
  1837.                 x2 = swap;
  1838.             }
  1839.  
  1840.             if( y2 < y1 ) {
  1841.                 swap = y1;
  1842.                 y1 = y2;
  1843.                 y2 = swap;
  1844.             }
  1845.  
  1846.             gad->g_Left = x1;
  1847.             gad->g_Top  = y1;
  1848.  
  1849.             if(!( gadgetxy_index[ gad->g_Kind ].Resize )) {
  1850.                 gad->g_Width  = gadgetxy_index[ gad->g_Kind ].Width;
  1851.                 gad->g_Height = gadgetxy_index[ gad->g_Kind ].Height;
  1852.             } else {
  1853.                 gad->g_Width  = x2 - x1 + 1;
  1854.                 gad->g_Height = y2 - y1 + 1;
  1855.             }
  1856.  
  1857.             CheckSize( gad );
  1858.  
  1859.             DisattivaTuttiGad();
  1860.  
  1861.             gad->g_flags2 |= G_ATTIVO;
  1862.  
  1863.             if( func = pre_gadget_index[ gad->g_Kind - 1 ])
  1864.                 (*func)( gad );
  1865.  
  1866.             buffer = 0L;
  1867.  
  1868.             func = modifica_index[ gad->g_Kind ];
  1869.             (*func)( gad );
  1870.  
  1871.             if( buffer ) {
  1872.  
  1873.                 if( gad->g_Tags & 1 ) {
  1874.                 ptr = gad->g_Titolo;
  1875.                 do{
  1876.                     ch = *ptr++;
  1877.                 } while(( ch != '_' ) && ( ch != '\0' ));
  1878.                 if( ch ) {
  1879.                     gad->g_Key = *ptr;
  1880.                     IE.win_info->wi_NumKeys += 1;
  1881.                 }
  1882.                 }
  1883.  
  1884.                 if(!( gad->g_Label[0] )) {
  1885.                 sprintf( gad->g_Label, "%sGad%03ld",
  1886.                      IE.win_info->wi_Label,
  1887.                      IE.win_info->wi_NewGadID );
  1888.                 IE.win_info->wi_NewGadID += 1;
  1889.                 }
  1890.  
  1891.  
  1892.                 if(!( IE.win_info->wi_NumGads ))
  1893.                 MenuGadgetAttiva();
  1894.  
  1895.                 IE.win_info->wi_NumGads += 1;
  1896.  
  1897.                 IE.win_info->wi_GadTypes[ gad->g_Kind - 1 ] += 1;
  1898.  
  1899.                 RifaiGadgets();
  1900.                 RinfrescaFinestra();
  1901.                 IE.flags &= ~SALVATO;
  1902.  
  1903.                 Stat( CatCompArray[ MSG_GAD_ADDED ].cca_Str, FALSE, 0 );
  1904.  
  1905.             } else {
  1906.  
  1907.                 Remove(( struct Node * )gad );
  1908.                 FreeObject( gad, IE_GADGET );
  1909.  
  1910.                 Stat( CatCompArray[ MSG_ABORTED ].cca_Str, FALSE, 0 );
  1911.             }
  1912.  
  1913.             } else {
  1914.             Stat( CatCompArray[ ERR_NOMEMORY ].cca_Str, TRUE, 0 );
  1915.             }
  1916.         }
  1917.         }
  1918.     }
  1919.     }
  1920.  
  1921.     return( TRUE );
  1922. }
  1923. ///
  1924.  
  1925. /// Elimina Gadget
  1926. BOOL RemGadgetClicked( void )
  1927. {
  1928.     return( DelGadMenued() );
  1929. }
  1930.  
  1931. BOOL DelGadMenued( void )
  1932. {
  1933.     struct GadgetInfo      *gad;
  1934.     struct IEXNode         *ex;
  1935.  
  1936.     if( TestAttivi() ) {
  1937.  
  1938.     if( IERequest( CatCompArray[ MSG_DELETE_GAD ].cca_Str,
  1939.                CatCompArray[ ANS_YES_NO ].cca_Str,
  1940.                MSG_DELETE_GAD, ANS_YES_NO )) {
  1941.  
  1942.         for( gad = IE.win_info->wi_Gadgets.mlh_Head; gad->g_Node.ln_Succ; gad = gad->g_Node.ln_Succ ) {
  1943.         if(( gad->g_flags2 & G_ATTIVO ) && ( gad->g_Kind < MIN_IEX_ID )) {
  1944.  
  1945.             Remove(( struct Node *)gad );
  1946.  
  1947.             IE.win_info->wi_NumGads -= 1;
  1948.  
  1949.             if( gad->g_Kind == BOOLEAN ) {
  1950.  
  1951.             FreeObject( gad, IE_BOOLEAN );
  1952.             IE.win_info->wi_NumBools -= 1;
  1953.  
  1954.             } else {
  1955.  
  1956.             IE.win_info->wi_GadTypes[ gad->g_Kind - 1 ] -= 1;
  1957.             FreeObject( gad, IE_GADGET );
  1958.             }
  1959.  
  1960.             gad = (struct GadgetInfo *)&IE.win_info->wi_Gadgets;
  1961.         }
  1962.         }
  1963.  
  1964.         for( ex = IE.Expanders.mlh_Head; ex->Node.ln_Succ; ex = ex->Node.ln_Succ ) {
  1965.         struct Expander    *IEXBase;
  1966.         IEXBase = ex->Base;
  1967.         IEX_Remove( ex->ID, &IE );
  1968.         }
  1969.  
  1970.         RifaiGadgets();
  1971.         RinfrescaFinestra();
  1972.  
  1973.         if(!( IE.win_info->wi_NumGads ))
  1974.         MenuGadgetDisattiva();
  1975.  
  1976.         IE.flags &= ~SALVATO;
  1977.         Stat( CatCompArray[ MSG_GAD_DELETED ].cca_Str, FALSE, 0 );
  1978.     } else
  1979.         Stat( CatCompArray[ MSG_ABORTED ].cca_Str, FALSE, 0 );
  1980.     }
  1981.  
  1982.     return( TRUE );
  1983. }
  1984. ///
  1985.  
  1986. /// Attacca/Stacca gadgets
  1987. void AttaccaGadgets( void )
  1988. {
  1989.     struct BooleanInfo *gad;
  1990.     struct Gadget      *glist;
  1991.  
  1992.     if(!( IE.mainprefs & STACCATI )) {
  1993.     if( IE.win_active ) {
  1994.  
  1995.         if( IE.win_info->wi_NumBools ) {
  1996.  
  1997.         gad = IE.win_info->wi_Gadgets.mlh_Head;
  1998.  
  1999.         while( gad->b_Kind != BOOLEAN )
  2000.             gad = gad->b_Node.ln_Succ;
  2001.  
  2002.         glist = &gad->b_NextGadget;
  2003.  
  2004.         } else
  2005.         glist = IE.win_info->wi_GList;
  2006.  
  2007.         if( glist ) {
  2008.         AddGList( IE.win_active, glist, -1, -1, NULL );
  2009.         RefreshGadgets( glist, IE.win_active, NULL );
  2010.         GT_RefreshWindow( IE.win_active, NULL );
  2011.         }
  2012.     }
  2013.     }
  2014. }
  2015.  
  2016. void StaccaGadgets( void )
  2017. {
  2018.     if(!( IE.mainprefs & STACCATI )) {
  2019.     if( IE.win_active ) {
  2020.         struct Gadget  *g;
  2021.  
  2022.         if( g = IE.win_active->FirstGadget ) {
  2023.  
  2024.         while( g->GadgetType & GTYP_SYSGADGET )
  2025.             if(!( g = g->NextGadget ))
  2026.             return;
  2027.  
  2028.         RemoveGList( IE.win_active, g, -1 );
  2029.         }
  2030.     }
  2031.     }
  2032. }
  2033. ///
  2034.  
  2035. /// Gadget Defaults
  2036. void IntegerDefault( struct GadgetInfo *gad )
  2037. {
  2038.     gad->g_Tags |= 8;
  2039.     ((struct IK)(gad->g_Data)).MaxC = 10;
  2040. }
  2041.  
  2042. void ListviewDefault( struct GadgetInfo *gad )
  2043. {
  2044.     ((struct LK)(gad->g_Data)).ScW = 16;
  2045. }
  2046.  
  2047. void MxDefault( struct GadgetInfo *gad )
  2048. {
  2049.     ((struct MK)(gad->g_Data)).Spc = 1;
  2050.     ListEditor( &gad->g_Scelte, TRUE, &gad->g_NumScelte, CatCompArray[ REQ_GAD_ITEMS ].cca_Str, REQ_GAD_ITEMS );
  2051. }
  2052.  
  2053. void CycleDefault( struct GadgetInfo *gad )
  2054. {
  2055.     ListEditor( &gad->g_Scelte, TRUE, &gad->g_NumScelte, CatCompArray[ REQ_GAD_ITEMS ].cca_Str, REQ_GAD_ITEMS );
  2056. }
  2057.  
  2058. void NumberDefault( struct GadgetInfo *gad )
  2059. {
  2060.     ((struct NK)(gad->g_Data)).MNL = 10;
  2061.     ((struct NK)(gad->g_Data)).FPen = -1;
  2062.     ((struct NK)(gad->g_Data)).BPen = -1;
  2063.     strcpy( ((struct NK)(gad->g_Data)).Format, "%ld" );
  2064. }
  2065.  
  2066. void PaletteDefault( struct GadgetInfo *gad )
  2067. {
  2068.     ((struct PK)(gad->g_Data)).Depth = ((struct PK)(gad->g_Data)).Color = 1;
  2069. }
  2070.  
  2071. void ScrollerDefault( struct GadgetInfo *gad )
  2072. {
  2073.     ((struct SK)(gad->g_Data)).Vis = 2;
  2074. }
  2075.  
  2076. void SliderDefault( struct GadgetInfo *gad )
  2077. {
  2078.     ((struct SlK)(gad->g_Data)).Max = 15;
  2079.     ((struct SlK)(gad->g_Data)).MLL = 2;
  2080.     strcpy( ((struct SlK)(gad->g_Data)).Format, "%ld" );
  2081. }
  2082.  
  2083. void StringDefault( struct GadgetInfo *gad )
  2084. {
  2085.     gad->g_Tags |= 8;
  2086. }
  2087.  
  2088. void TextDefault( struct GadgetInfo *gad )
  2089. {
  2090.     ((struct TK)(gad->g_Data)).FPen = -1;
  2091.     ((struct TK)(gad->g_Data)).BPen = -1;
  2092. }
  2093. ///
  2094.  
  2095. /// Routines che settano le tags dei gadgets
  2096. void SetUnder( ULONG *array, ULONG tags )
  2097. {
  2098.     array[1] = ( tags & 1 ) ? '_' : 0xFF;
  2099. }
  2100.  
  2101. void SetButtonTag( ULONG *array, ULONG tags, struct GadgetInfo *gad )
  2102. {
  2103.     array[3] = ( tags & 2 ) ? TRUE : FALSE;
  2104. }
  2105.  
  2106. void SetCheckboxTag( ULONG *array, ULONG tags, struct GadgetInfo *gad )
  2107. {
  2108.     array[3] = ( tags & 2 ) ? TRUE : FALSE;
  2109.     array[5] = ( tags & 4 ) ? TRUE : FALSE;
  2110.     array[7] = ( tags & 8 ) ? TRUE : FALSE;
  2111. }
  2112.  
  2113. void SetIntegerTag( ULONG *array, ULONG tags, struct GadgetInfo *gad )
  2114. {
  2115.     array[ 3] = ((struct IK)(gad->g_Data)).Num;
  2116.     array[ 5] = stringjusts[( ((struct IK)(gad->g_Data)).Just )];
  2117.     array[ 7] = ( tags & 2 ) ? TRUE : FALSE;
  2118.     array[ 9] = ( tags & 8 ) ? TRUE : FALSE;
  2119.     array[11] = ( tags & 0x20 ) ? TRUE : FALSE;
  2120. }
  2121.  
  2122. void SetListviewTag( ULONG *array, ULONG tags, struct GadgetInfo *gad )
  2123. {
  2124.     array[ 3] = ((struct LK)(gad->g_Data)).ScW;
  2125.     array[ 5] = ((struct LK)(gad->g_Data)).Spc;
  2126.     array[ 7] = ( tags & 2 ) ? TRUE : FALSE;
  2127.     array[11] = ( tags & 4 ) ? TRUE : FALSE;
  2128.     array[ 9] = NULL;
  2129.     if( gad->g_NumScelte )
  2130.     array[9] = &gad->g_Scelte;
  2131. }
  2132.  
  2133. void SetMxTag( ULONG *array, ULONG tags, struct GadgetInfo *gad )
  2134. {
  2135.     array[ 5] = ((struct MK)(gad->g_Data)).Act;
  2136.     array[ 7] = ((struct MK)(gad->g_Data)).Spc;
  2137.     array[ 9] = gadget_flags[( ((struct MK)(gad->g_Data)).TitPlc )];
  2138.     array[11] = ( tags & 2 ) ? TRUE : FALSE;
  2139.     array[13] = ( tags & 4 ) ? TRUE : FALSE;
  2140. }
  2141.  
  2142. void SetNumberTag( ULONG *array, ULONG tags, struct GadgetInfo *gad )
  2143. {
  2144.     array[ 3] = ((struct NK)(gad->g_Data)).Num;
  2145.     array[ 5] = ((struct NK)(gad->g_Data)).Just;
  2146.     array[ 7] = ((struct NK)(gad->g_Data)).MNL;
  2147.     array[ 9] = ( tags & 2 ) ? TRUE : FALSE;
  2148.     array[11] = ( tags & 4 ) ? TRUE : FALSE;
  2149.     array[13] = ((struct NK)(gad->g_Data)).Format;
  2150.  
  2151.     if( ((struct NK)(gad->g_Data)).FPen != -1 ) {
  2152.     array[14] = GTNM_FrontPen;
  2153.     array[15] = ((struct NK)(gad->g_Data)).FPen;
  2154.     } else {
  2155.     array[14] = TAG_IGNORE;
  2156.     }
  2157.  
  2158.     if( ((struct NK)(gad->g_Data)).BPen != -1 ) {
  2159.     array[16] = GTNM_BackPen;
  2160.     array[17] = ((struct NK)(gad->g_Data)).BPen;
  2161.     } else {
  2162.     array[16] = TAG_IGNORE;
  2163.     }
  2164. }
  2165.  
  2166. void SetCycleTag( ULONG *array, ULONG tags, struct GadgetInfo *gad )
  2167. {
  2168.     array[ 5] = ((struct CK)(gad->g_Data)).Act;
  2169.     array[ 7] = ( tags & 2 ) ? TRUE : FALSE;
  2170. }
  2171.  
  2172. void SetPaletteTag( ULONG *array, ULONG tags, struct GadgetInfo *gad )
  2173. {
  2174.     array[ 3] = ((struct PK)(gad->g_Data)).Depth;
  2175.     array[ 5] = ((struct PK)(gad->g_Data)).Color;
  2176.     array[ 7] = ((struct PK)(gad->g_Data)).ColOff;
  2177.     array[ 9] = ((struct PK)(gad->g_Data)).IW;
  2178.     array[11] = ((struct PK)(gad->g_Data)).IH;
  2179.     if( ((struct PK)(gad->g_Data)).NumCol ) {
  2180.     array[12] = GTPA_NumColors;
  2181.     array[13] = ((struct PK)(gad->g_Data)).NumCol;
  2182.     } else {
  2183.     array[12] = TAG_IGNORE;
  2184.     }
  2185.     array[15] = ( tags & 2 ) ? TRUE : FALSE;
  2186. }
  2187.  
  2188. void SetScrollerTag( ULONG *array, ULONG tags, struct GadgetInfo *gad )
  2189. {
  2190.     array[ 3] = ((struct SK)(gad->g_Data)).Top;
  2191.     array[ 5] = ((struct SK)(gad->g_Data)).Tot;
  2192.     array[ 7] = ((struct SK)(gad->g_Data)).Vis;
  2193.     array[ 9] = ((struct SK)(gad->g_Data)).Arr;
  2194.     array[11] = ( ((struct SK)(gad->g_Data)).Free ) + 1;
  2195.     array[13] = ( tags & 2 ) ? TRUE : FALSE;
  2196. }
  2197.  
  2198. void SetSliderTag( ULONG *array, ULONG tags, struct GadgetInfo *gad )
  2199. {
  2200.     array[ 3] = ((struct SlK)(gad->g_Data)).Min;
  2201.     array[ 5] = ((struct SlK)(gad->g_Data)).Max;
  2202.     array[ 7] = ((struct SlK)(gad->g_Data)).Level;
  2203.     array[ 9] = ((struct SlK)(gad->g_Data)).MLL;
  2204.     array[11] = ((struct SlK)(gad->g_Data)).Format;
  2205.     array[13] = gadget_flags[( ((struct SlK)(gad->g_Data)).LevPlc )];
  2206.     if( ((struct SlK)(gad->g_Data)).MPL ) {
  2207.     array[14] = GTSL_MaxPixelLen;
  2208.     array[15] = ((struct SlK)(gad->g_Data)).MPL;
  2209.     } else {
  2210.     array[14] = TAG_IGNORE;
  2211.     }
  2212.     array[17] = ((struct SlK)(gad->g_Data)).Just;
  2213.     array[19] = ((struct SlK)(gad->g_Data)).Free + 1;
  2214.     array[21] = ( tags & 2 ) ? TRUE : FALSE;
  2215. }
  2216.  
  2217. void SetStringTag( ULONG *array, ULONG tags, struct GadgetInfo *gad )
  2218. {
  2219.     array[ 3] = ((struct StK)(gad->g_Data)).MaxC;
  2220.     array[ 5] = stringjusts[( ((struct StK)(gad->g_Data)).Just )];
  2221.     array[ 7] = gad->g_ExtraMem;
  2222.     array[ 9] = ( tags & 2 ) ? TRUE : FALSE;
  2223.     array[11] = ( tags & 8 ) ? TRUE : FALSE;
  2224.     array[13] = ( tags & 0x10 ) ? TRUE : FALSE;
  2225.     array[15] = ( tags & 0x20 ) ? TRUE : FALSE;
  2226. }
  2227.  
  2228. void SetTextTag( ULONG *array, ULONG tags, struct GadgetInfo *gad )
  2229. {
  2230.     array[ 3] = ((struct TK)(gad->g_Data)).Just;
  2231.     array[ 5] = gad->g_ExtraMem;
  2232.     array[ 7] = ( tags & 4 ) ? TRUE : FALSE;
  2233.     array[ 9] = ( tags & 8 ) ? TRUE : FALSE;
  2234.  
  2235.     if( ((struct TK)(gad->g_Data)).FPen != -1 ) {
  2236.     array[10] = GTTX_FrontPen;
  2237.     array[11] = ((struct TK)(gad->g_Data)).FPen;
  2238.     } else {
  2239.     array[10] = TAG_IGNORE;
  2240.     }
  2241.  
  2242.     if( ((struct TK)(gad->g_Data)).BPen != -1 ) {
  2243.     array[12] = GTTX_BackPen;
  2244.     array[13] = ((struct TK)(gad->g_Data)).BPen;
  2245.     } else {
  2246.     array[12] = TAG_IGNORE;
  2247.     }
  2248. }
  2249. ///
  2250.  
  2251. /// Scelte Gadgets
  2252. BOOL ScelteMenued( void )
  2253. {
  2254.     struct GadgetInfo  *gad;
  2255.     BOOL                min;
  2256.  
  2257.     for( gad = IE.win_info->wi_Gadgets.mlh_Head; gad->g_Node.ln_Succ; gad = gad->g_Node.ln_Succ ) {
  2258.     if( gad->g_flags2 & G_ATTIVO ) {
  2259.         BOOL    ok = FALSE;
  2260.  
  2261.         if(( gad->g_Kind == LISTVIEW_KIND ) || ( gad->g_Kind == MX_KIND ) || ( gad->g_Kind == CYCLE_KIND ))
  2262.         ok = TRUE;
  2263.         else {
  2264.         if( gad->g_Kind >= MIN_IEX_ID ) {
  2265.             struct IEXNode *ex;
  2266.  
  2267.             ex = IE.Expanders.mlh_Head;
  2268.             while( ex->ID != gad->g_Kind )
  2269.             ex = ex->Node.ln_Succ;
  2270.  
  2271.             if(!( ex->Base->HasItems ))
  2272.             return( TRUE );
  2273.         }
  2274.         }
  2275.  
  2276.         if( ok ) {
  2277.         if(( gad->g_Kind == MX_KIND ) || ( gad->g_Kind == CYCLE_KIND ))
  2278.             min = TRUE;
  2279.         else
  2280.             min = FALSE;
  2281.  
  2282.         ListEditor( &gad->g_Scelte, min, &gad->g_NumScelte, CatCompArray[ REQ_GAD_ITEMS ].cca_Str, REQ_GAD_ITEMS );
  2283.  
  2284.         RifaiGadgets();
  2285.         }
  2286.     }
  2287.     }
  2288.  
  2289.     RinfrescaFinestra();
  2290.  
  2291.     return( TRUE );
  2292. }
  2293. ///
  2294.  
  2295. /// List Editor
  2296. void ListEditor( struct MinList *list, BOOL min, UWORD *num, STRPTR titolo, ULONG titn )
  2297. {
  2298.     int                     ret;
  2299.     STRPTR                  old_tit;
  2300.     struct GadgetScelta    *gs, *gs2;
  2301.  
  2302.     NewList( &ListEd_List );
  2303.  
  2304.     for( gs = list->mlh_Head; gs->gs_Node.ln_Succ; gs = gs->gs_Node.ln_Succ ) {
  2305.     if( gs2 = AllocObject( IE_ITEM )) {
  2306.         CopyMem( (char *)gs, (char *)gs2, sizeof( struct GadgetScelta ) );
  2307.         gs2->gs_Node.ln_Name = gs2->gs_Testo;
  2308.         AddTail(( struct List * )&ListEd_List, (struct Node *)gs2 );
  2309.     } else {
  2310.         Stat( CatCompArray[ ERR_NOMEMORY ].cca_Str, TRUE, 0 );
  2311.         return;
  2312.     }
  2313.     }
  2314.  
  2315.     buffer3 = list;
  2316.  
  2317.     LockAllWindows();
  2318.  
  2319.     old_tit = (STRPTR)ListEdWTags[9].ti_Data;
  2320.     buffer = min;
  2321.     buffer2 = num;
  2322.  
  2323.     if( titolo ) {
  2324.     if(( LocaleBase ) && ( titn ))
  2325.         titolo = GetCatalogStr( Catalog, titn, titolo );
  2326.  
  2327.     ListEdWTags[9].ti_Data = titolo;
  2328.     }
  2329.  
  2330.     LayoutWindow( ListEdWTags );
  2331.     ret = OpenListEdWindow();
  2332.     PostOpenWindow( ListEdWTags );
  2333.  
  2334.     if( ret ) {
  2335.     DisplayBeep( Scr );
  2336.     } else {
  2337.  
  2338.     ListTag[1] = &ListEd_List;
  2339.     GT_SetGadgetAttrsA( ListEdGadgets[ GD_LE_List ], ListEdWnd,
  2340.                 NULL, (struct TagItem *)ListTag );
  2341.  
  2342.     List2Tag[1] = List2Tag[3] = 0;
  2343.  
  2344.     buffer4 = ListEd_List.mlh_Head;
  2345.  
  2346.     if( *num )
  2347.         AttivaListEdGadgets();
  2348.  
  2349.     while( ReqHandle( ListEdWnd, HandleListEdIDCMP ));
  2350.  
  2351.     }
  2352.  
  2353.     ListEdWTags[9].ti_Data = old_tit;
  2354.  
  2355.     CloseListEdWindow();
  2356.     UnlockAllWindows();
  2357.  
  2358. }
  2359.  
  2360. BOOL LE_AnnullaKeyPressed( void )
  2361. {
  2362.     return( LE_AnnullaClicked() );
  2363. }
  2364.  
  2365. BOOL LE_AnnullaClicked( void )
  2366. {
  2367.     struct GadgetScelta *gs;
  2368.  
  2369.     *((UWORD *)buffer2) = 0;
  2370.  
  2371.     for( gs = ((struct MinList *)buffer3)->mlh_Head; gs->gs_Node.ln_Succ; gs = gs->gs_Node.ln_Succ )
  2372.     *((UWORD *)buffer2) += 1;
  2373.  
  2374.     Stat( CatCompArray[ MSG_ABORTED ].cca_Str, FALSE, 0 );
  2375.  
  2376.     return( FALSE );
  2377. }
  2378.  
  2379. BOOL LE_OkKeyPressed( void )
  2380. {
  2381.     return( LE_OkClicked() );
  2382. }
  2383.  
  2384. BOOL LE_OkClicked( void )
  2385. {
  2386.     struct GadgetScelta *gs;
  2387.  
  2388.     if( buffer ) {
  2389.     if( *((UWORD *)buffer2) < 2 ) {
  2390.         IERequest( CatCompArray[ MSG_TWO_ITEMS ].cca_Str, ok_txt, 0, 0 );
  2391.         return( TRUE );
  2392.     }
  2393.     }
  2394.  
  2395.     while( gs = RemTail((struct List *)buffer3 ))
  2396.     FreeObject( gs, IE_ITEM );
  2397.  
  2398.     while( gs = RemHead(( struct List * )&ListEd_List ))
  2399.     AddTail((struct List *)buffer3, (struct Node *)gs );
  2400.  
  2401.     return( FALSE );
  2402. }
  2403.  
  2404. void ListEdStaccaLista( void )
  2405. {
  2406.     ListTag[1] = NULL;
  2407.     GT_SetGadgetAttrsA( ListEdGadgets[ GD_Lista ], ListEdWnd, NULL, (struct TagItem *)ListTag );
  2408. }
  2409.  
  2410. void ListEdAttaccaLista( void )
  2411. {
  2412.     ListTag[1] = &ListEd_List;
  2413.     GT_SetGadgetAttrsA( ListEdGadgets[ GD_Lista ], ListEdWnd, NULL, (struct TagItem *)ListTag );
  2414.     GT_SetGadgetAttrsA( ListEdGadgets[ GD_Lista ], ListEdWnd, NULL, (struct TagItem *)List2Tag );
  2415. }
  2416.  
  2417. BOOL LE_NewKeyPressed( void )
  2418. {
  2419.     return( LE_NewClicked() );
  2420. }
  2421.  
  2422. BOOL LE_NewClicked( void )
  2423. {
  2424.     struct GadgetScelta    *gs, *g2;
  2425.     int                     cnt;
  2426.  
  2427.     if( gs = AllocObject( IE_ITEM )) {
  2428.  
  2429.     strcpy( gs->gs_Testo, "(new)" );
  2430.  
  2431.     g2 = &ListEd_List;
  2432.     for( cnt = 0; cnt <= List2Tag[1]; cnt++ )
  2433.         g2 = g2->gs_Node.ln_Succ;
  2434.  
  2435.     buffer4 = gs;
  2436.  
  2437.     List2Tag[1] += 1;
  2438.     List2Tag[3] = List2Tag[1];
  2439.  
  2440.     ListEdStaccaLista();
  2441.     Insert((struct List *)&ListEd_List, (struct Node *)gs, (struct Node *)g2 );
  2442.     ListEdAttaccaLista();
  2443.  
  2444.     *((UWORD *)buffer2) += 1;
  2445.  
  2446.     AttivaListEdGadgets();
  2447.  
  2448.     ActivateGadget( ListEdGadgets[ GD_LE_In ], ListEdWnd, NULL );
  2449.  
  2450.     IE.flags &= ~SALVATO;
  2451.  
  2452.     } else {
  2453.     Stat( CatCompArray[ ERR_NOMEMORY ].cca_Str, TRUE, 0 );
  2454.     }
  2455.  
  2456.     return( TRUE );
  2457. }
  2458.  
  2459. void AttivaListEdGadgets( void )
  2460. {
  2461.     int pos;
  2462.  
  2463.     pos = RemoveGList( ListEdWnd, &LE_UpGadget, 4 );
  2464.  
  2465.     LE_UpGadget.Flags     &= ~GFLG_DISABLED;
  2466.     LE_TopGadget.Flags    &= ~GFLG_DISABLED;
  2467.     LE_DownGadget.Flags   &= ~GFLG_DISABLED;
  2468.     LE_BottomGadget.Flags &= ~GFLG_DISABLED;
  2469.  
  2470.     AddGList( ListEdWnd, &LE_UpGadget, pos, 4, NULL );
  2471.     RefreshGList( &LE_UpGadget, ListEdWnd, NULL, 4 );
  2472.  
  2473.     DisableTag[1] = FALSE;
  2474.     GT_SetGadgetAttrsA( ListEdGadgets[ GD_LE_In ], ListEdWnd,
  2475.             NULL, (struct TagItem *)DisableTag );
  2476.     GT_SetGadgetAttrsA( ListEdGadgets[ GD_LE_Del ], ListEdWnd,
  2477.             NULL, (struct TagItem *)DisableTag );
  2478.  
  2479.     SettaListEdIn();
  2480. }
  2481.  
  2482. void SettaListEdIn( void )
  2483. {
  2484.     StringTag[1] = ((struct Node *)buffer4)->ln_Name;
  2485.     GT_SetGadgetAttrsA( ListEdGadgets[ GD_LE_In ], ListEdWnd, NULL, (struct TagItem *)StringTag );
  2486. }
  2487.  
  2488. void DisattivaListEdGadgets( void )
  2489. {
  2490.     int pos;
  2491.  
  2492.     pos = RemoveGList( ListEdWnd, &LE_UpGadget, 4 );
  2493.  
  2494.     LE_UpGadget.Flags     |= GFLG_DISABLED;
  2495.     LE_TopGadget.Flags    |= GFLG_DISABLED;
  2496.     LE_DownGadget.Flags   |= GFLG_DISABLED;
  2497.     LE_BottomGadget.Flags |= GFLG_DISABLED;
  2498.  
  2499.     AddGList( ListEdWnd, &LE_UpGadget, pos, 4, NULL );
  2500.     RefreshGList( &LE_UpGadget, ListEdWnd, NULL, 4 );
  2501.  
  2502.     DisableTag[1] = TRUE;
  2503.     GT_SetGadgetAttrsA( ListEdGadgets[ GD_LE_In ], ListEdWnd,
  2504.             NULL, (struct TagItem *)DisableTag );
  2505.     GT_SetGadgetAttrsA( ListEdGadgets[ GD_LE_Del ], ListEdWnd,
  2506.             NULL, (struct TagItem *)DisableTag );
  2507. }
  2508.  
  2509. BOOL LE_DelKeyPressed( void )
  2510. {
  2511.     if( *((UWORD *)buffer2 ))
  2512.     return( LE_DelClicked() );
  2513.     else
  2514.     return( TRUE );
  2515. }
  2516.  
  2517. BOOL LE_DelClicked( void )
  2518. {
  2519.     struct Node *pred;
  2520.  
  2521.     pred = ((struct Node *)buffer4)->ln_Pred;
  2522.  
  2523.     if(!( pred->ln_Pred )) {
  2524.     pred = ((struct Node *)buffer4)->ln_Succ;
  2525.     List2Tag[1] += 1;
  2526.     } else {
  2527.     List2Tag[1] -= 1;
  2528.     }
  2529.  
  2530.     List2Tag[3] = List2Tag[1];
  2531.  
  2532.     ListEdStaccaLista();
  2533.     Remove((struct Node *)buffer4 );
  2534.  
  2535.     FreeObject( buffer4, IE_ITEM );
  2536.  
  2537.     buffer4 = pred;
  2538.  
  2539.     *((UWORD *)buffer2) -= 1;
  2540.  
  2541.     if( *((UWORD *)buffer2 )) {
  2542.     ListEdAttaccaLista();
  2543.     SettaListEdIn();
  2544.     } else {
  2545.     DisattivaListEdGadgets();
  2546.     }
  2547.  
  2548.     IE.flags &= ~SALVATO;
  2549.  
  2550.     return( TRUE );
  2551. }
  2552.  
  2553. BOOL LE_UpClicked( void )
  2554. {
  2555.     if( List2Tag[1] ) {
  2556.     ListEdStaccaLista();
  2557.     NodeUp((struct Node *)buffer4);
  2558.     List2Tag[1] -= 1;
  2559.     List2Tag[3] = List2Tag[1];
  2560.     ListEdAttaccaLista();
  2561.     }
  2562.  
  2563.     return( TRUE );
  2564. }
  2565.  
  2566. BOOL LE_TopClicked( void )
  2567. {
  2568.     if( List2Tag[1] ) {
  2569.     ListEdStaccaLista();
  2570.     Remove((struct Node *)buffer4);
  2571.     AddHead(( struct List * )&ListEd_List, (struct Node *)buffer4 );
  2572.     List2Tag[1] = List2Tag[3] = 0;
  2573.     ListEdAttaccaLista();
  2574.     }
  2575.  
  2576.     return( TRUE );
  2577. }
  2578.  
  2579. BOOL LE_DownClicked( void )
  2580. {
  2581.     if( List2Tag[1] < *((UWORD *)buffer2) - 1 ) {
  2582.     ListEdStaccaLista();
  2583.     NodeDown((struct Node *)buffer4);
  2584.     List2Tag[1] += 1;
  2585.     List2Tag[3] = List2Tag[1];
  2586.     ListEdAttaccaLista();
  2587.     }
  2588.  
  2589.     return( TRUE );
  2590. }
  2591.  
  2592. BOOL LE_BottomClicked( void )
  2593. {
  2594.     if( List2Tag[1] < *((UWORD *)buffer2) - 1 ) {
  2595.     ListEdStaccaLista();
  2596.     Remove((struct Node *)buffer4);
  2597.     AddTail(( struct List * )&ListEd_List, (struct Node *)buffer4 );
  2598.     List2Tag[1] = List2Tag[3] = *((UWORD *)buffer2) - 1;
  2599.     ListEdAttaccaLista();
  2600.     }
  2601.  
  2602.     return( TRUE );
  2603. }
  2604.  
  2605. BOOL ListEdVanillaKey( void )
  2606. {
  2607.     if( ListEdMsg.Code == 0x09 ) {
  2608.     if(!( ListEdGadgets[ GD_LE_In ]->Flags & GFLG_DISABLED ))
  2609.         ActivateGadget( ListEdGadgets[ GD_LE_In ], ListEdWnd, NULL );
  2610.     }
  2611.  
  2612.     return( TRUE );
  2613. }
  2614.  
  2615. BOOL ListEdRawKey( void )
  2616. {
  2617.     switch( ListEdMsg.Code ) {
  2618.     case 0x43:                          // Enter
  2619.     case 0x44:                          // Return
  2620.         return( LE_OkClicked() );
  2621.         break;
  2622.  
  2623.     case 0x45:                          // ESC
  2624.         return( LE_AnnullaClicked() );
  2625.         break;
  2626.  
  2627.     case 0x4C:                          // Su
  2628.         if( List2Tag[1] ) {
  2629.         List2Tag[1] -= 1;
  2630.         buffer4 = ((struct Node *)buffer4)->ln_Pred;
  2631.         } else {
  2632.         List2Tag[1] = *((UWORD *)buffer2) - 1;
  2633.         buffer4 = ListEd_List.mlh_TailPred;
  2634.         }
  2635.         List2Tag[3] = List2Tag[1];
  2636.         GT_SetGadgetAttrsA( ListEdGadgets[ GD_Lista ], ListEdWnd, NULL, (struct TagItem *)List2Tag );
  2637.         SettaListEdIn();
  2638.         break;
  2639.  
  2640.     case 0x4D:                          // Giù
  2641.         if( List2Tag[1] < *((UWORD *)buffer2) - 1 ) {
  2642.         List2Tag[1] += 1;
  2643.         buffer4 = ((struct Node *)buffer4)->ln_Succ;
  2644.         } else {
  2645.         List2Tag[1] = 0;
  2646.         buffer4 = ListEd_List.mlh_Head;
  2647.         }
  2648.         List2Tag[3] = List2Tag[1];
  2649.         GT_SetGadgetAttrsA( ListEdGadgets[ GD_Lista ], ListEdWnd, NULL, (struct TagItem *)List2Tag );
  2650.         SettaListEdIn();
  2651.         break;
  2652.     }
  2653.  
  2654.     return( TRUE );
  2655. }
  2656.  
  2657. BOOL LE_InClicked( void )
  2658. {
  2659.     strcpy( ((struct GadgetScelta *)buffer4)->gs_Testo,
  2660.         GetString( ListEdGadgets[ GD_LE_In ]) );
  2661.  
  2662.     GT_RefreshWindow( ListEdWnd, NULL );
  2663.  
  2664.     return( TRUE );
  2665. }
  2666.  
  2667. BOOL LE_ListClicked( void )
  2668. {
  2669.     struct Node *no;
  2670.     int          cnt;
  2671.  
  2672.     List2Tag[1] = List2Tag[3] = ListEdMsg.Code;
  2673.  
  2674.     no = (struct Node *)&ListEd_List;
  2675.  
  2676.     for( cnt = 0; cnt <= List2Tag[1]; cnt++ )
  2677.     no = no->ln_Succ;
  2678.  
  2679.     buffer4 = no;
  2680.  
  2681.     return( TRUE );
  2682. }
  2683. ///
  2684.  
  2685. /// Parametri BUTTON
  2686. void ParametriButton( struct GadgetInfo *gad )
  2687. {
  2688.     int     ret;
  2689.  
  2690.     LayoutWindow( ButTagWTags );
  2691.     ret = OpenButTagWindow();
  2692.     PostOpenWindow( ButTagWTags );
  2693.  
  2694.     if( ret ) {
  2695.     DisplayBeep( Scr );
  2696.     } else {
  2697.  
  2698.     StringTag[1] = gad->g_Titolo;
  2699.     GT_SetGadgetAttrsA( ButTagGadgets[ GD_BT_Tit ], ButTagWnd,
  2700.                 NULL, (struct TagItem *)StringTag );
  2701.  
  2702.     StringTag[1] = gad->g_Label;
  2703.     GT_SetGadgetAttrsA( ButTagGadgets[ GD_BT_Label ], ButTagWnd,
  2704.                 NULL, (struct TagItem *)StringTag );
  2705.  
  2706.     ret = 0;
  2707.     while((!( gadget_flags[ ret ] & gad->g_Flags )) && ret < 5 )
  2708.         ret += 1;
  2709.  
  2710.     CycleTag[1] = ret;
  2711.     GT_SetGadgetAttrsA( ButTagGadgets[ GD_BT_PosTit ], ButTagWnd,
  2712.                 NULL, (struct TagItem *)CycleTag );
  2713.  
  2714.     CheckedTag[1] = ( gad->g_Tags & 1 ) ? TRUE : FALSE;
  2715.     GT_SetGadgetAttrsA( ButTagGadgets[ GD_BT_Und ], ButTagWnd,
  2716.                 NULL, (struct TagItem *)CheckedTag );
  2717.  
  2718.     CheckedTag[1] = ( gad->g_Flags & NG_HIGHLABEL ) ? TRUE : FALSE;
  2719.     GT_SetGadgetAttrsA( ButTagGadgets[ GD_BT_High ], ButTagWnd,
  2720.                 NULL, (struct TagItem *)CheckedTag );
  2721.  
  2722.     CheckedTag[1] = ( gad->g_Tags & 2 ) ? TRUE : FALSE;
  2723.     GT_SetGadgetAttrsA( ButTagGadgets[ GD_BT_Disab ], ButTagWnd,
  2724.                 NULL, (struct TagItem *)CheckedTag );
  2725.  
  2726.     CheckedTag[1] = ( gad->g_Tags & 4 ) ? TRUE : FALSE;
  2727.     GT_SetGadgetAttrsA( ButTagGadgets[ GD_BT_Imm ], ButTagWnd,
  2728.                 NULL, (struct TagItem *)CheckedTag );
  2729.  
  2730.     ActivateGadget( ButTagGadgets[ GD_BT_Tit ], ButTagWnd, NULL );
  2731.  
  2732.     if( gad->g_Key )
  2733.         IE.win_info->wi_NumKeys -= 1;
  2734.  
  2735.     buffer4 = (APTR)gad->g_Flags;
  2736.     buffer2 = gad->g_Tags;
  2737.     buffer3 = gad;
  2738.     buffer  = FALSE;
  2739.  
  2740.     while( ReqHandle( ButTagWnd, HandleButTagIDCMP ));
  2741.     }
  2742.  
  2743.     CloseButTagWindow();
  2744. }
  2745.  
  2746. BOOL BT_TitClicked( void )
  2747. {
  2748.     ActivateGadget( ButTagGadgets[ GD_BT_Label ], ButTagWnd, NULL );
  2749.     return( TRUE );
  2750. }
  2751.  
  2752. BOOL BT_LabelClicked( void )
  2753. {
  2754.     return( TRUE );
  2755. }
  2756.  
  2757. BOOL ButTagVanillaKey( void )
  2758. {
  2759.     switch( ButTagMsg.Code ) {
  2760.     case 13:
  2761.         return( BT_OkClicked() );
  2762.     case 27:
  2763.         return( BT_AnnullaClicked() );
  2764.     }
  2765. }
  2766.  
  2767. BOOL BT_AnnullaKeyPressed( void )
  2768. {
  2769.     return( BT_AnnullaClicked() );
  2770. }
  2771.  
  2772. BOOL BT_AnnullaClicked( void )
  2773. {
  2774.     ((struct GadgetInfo *)buffer3)->g_Flags = buffer4;
  2775.     ((struct GadgetInfo *)buffer3)->g_Tags  = buffer2;
  2776.     return( FALSE );
  2777. }
  2778.  
  2779. BOOL BT_OkKeyPressed( void )
  2780. {
  2781.     return( BT_OkClicked() );
  2782. }
  2783.  
  2784. BOOL BT_OkClicked( void )
  2785. {
  2786.     buffer = TRUE;
  2787.  
  2788.     strcpy( ((struct GadgetInfo *)buffer3)->g_Titolo,
  2789.         GetString( ButTagGadgets[ GD_BT_Tit ]));
  2790.  
  2791.     STRPTR label;
  2792.  
  2793.     label = GetString( ButTagGadgets[ GD_BT_Label ]);
  2794.  
  2795.     if( label[0] )
  2796.     strcpy( ((struct GadgetInfo *)buffer3)->g_Label, label );
  2797.  
  2798.     return( FALSE );
  2799. }
  2800.  
  2801. BOOL BT_UndKeyPressed( void )
  2802. {
  2803.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 1 ) ? FALSE : TRUE;
  2804.     GT_SetGadgetAttrsA( ButTagGadgets[ GD_BT_Und ], ButTagWnd,
  2805.             NULL, (struct TagItem *)CheckedTag );
  2806.  
  2807.     return( BT_UndClicked() );
  2808. }
  2809.  
  2810. BOOL BT_UndClicked( void )
  2811. {
  2812.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 1;
  2813.     return( TRUE );
  2814. }
  2815.  
  2816. BOOL BT_HighKeyPressed( void )
  2817. {
  2818.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Flags & NG_HIGHLABEL ) ? FALSE : TRUE;
  2819.     GT_SetGadgetAttrsA( ButTagGadgets[ GD_BT_High ], ButTagWnd,
  2820.             NULL, (struct TagItem *)CheckedTag );
  2821.  
  2822.     return( BT_HighClicked() );
  2823. }
  2824.  
  2825. BOOL BT_HighClicked( void )
  2826. {
  2827.     ((struct GadgetInfo *)buffer3)->g_Flags ^= NG_HIGHLABEL;
  2828.     return( TRUE );
  2829. }
  2830.  
  2831. BOOL BT_DisabKeyPressed( void )
  2832. {
  2833.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 2 ) ? FALSE : TRUE;
  2834.     GT_SetGadgetAttrsA( ButTagGadgets[ GD_BT_Disab ], ButTagWnd,
  2835.             NULL, (struct TagItem *)CheckedTag );
  2836.  
  2837.     return( BT_DisabClicked() );
  2838. }
  2839.  
  2840. BOOL BT_DisabClicked( void )
  2841. {
  2842.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 2;
  2843.     return( TRUE );
  2844. }
  2845.  
  2846. BOOL BT_ImmKeyPressed( void )
  2847. {
  2848.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 4 ) ? FALSE : TRUE;
  2849.     GT_SetGadgetAttrsA( ButTagGadgets[ GD_BT_Imm ], ButTagWnd,
  2850.             NULL, (struct TagItem *)CheckedTag );
  2851.  
  2852.     return( BT_ImmClicked() );
  2853. }
  2854.  
  2855. BOOL BT_ImmClicked( void )
  2856. {
  2857.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 4;
  2858.     return( TRUE );
  2859. }
  2860.  
  2861. BOOL BT_PosTitKeyPressed( void )
  2862. {
  2863.     if( CycleTag[1] < 5 )
  2864.     CycleTag[1] += 1;
  2865.     else
  2866.     CycleTag[1] = 0;
  2867.  
  2868.     GT_SetGadgetAttrsA( ButTagGadgets[ GD_BT_PosTit ], ButTagWnd,
  2869.             NULL, (struct TagItem *)CycleTag );
  2870.  
  2871.     ButTagMsg.Code = CycleTag[1];
  2872.  
  2873.     return( BT_PosTitClicked() );
  2874. }
  2875.  
  2876. BOOL BT_PosTitClicked( void )
  2877. {
  2878.     ULONG   t;
  2879.  
  2880.     CycleTag[1] = ButTagMsg.Code;
  2881.  
  2882.     t = ((struct GadgetInfo *)buffer3)->g_Flags & 32;
  2883.     ((struct GadgetInfo *)buffer3)->g_Flags = t | gadget_flags[ ButTagMsg.Code ];
  2884.  
  2885.     return( TRUE );
  2886. }
  2887. ///
  2888. /// Parametri CHECKBOX
  2889. void ParametriCheckbox( struct GadgetInfo *gad )
  2890. {
  2891.     int     ret;
  2892.  
  2893.     LayoutWindow( ChkTagWTags );
  2894.     ret = OpenChkTagWindow();
  2895.     PostOpenWindow( ChkTagWTags );
  2896.  
  2897.     if( ret ) {
  2898.     DisplayBeep( Scr );
  2899.     } else {
  2900.  
  2901.     StringTag[1] = gad->g_Titolo;
  2902.     GT_SetGadgetAttrsA( ChkTagGadgets[ GD_CT_Tit ], ChkTagWnd,
  2903.                 NULL, (struct TagItem *)StringTag );
  2904.  
  2905.     StringTag[1] = gad->g_Label;
  2906.     GT_SetGadgetAttrsA( ChkTagGadgets[ GD_CT_Label ], ChkTagWnd,
  2907.                 NULL, (struct TagItem *)StringTag );
  2908.  
  2909.     ret = 0;
  2910.     while((!( gadget_flags[ ret ] & gad->g_Flags )) && ret < 5 )
  2911.         ret += 1;
  2912.  
  2913.     CycleTag[1] = ret;
  2914.     GT_SetGadgetAttrsA( ChkTagGadgets[ GD_CT_PosTit ], ChkTagWnd,
  2915.                 NULL, (struct TagItem *)CycleTag );
  2916.  
  2917.     CheckedTag[1] = ( gad->g_Tags & 1 ) ? TRUE : FALSE;
  2918.     GT_SetGadgetAttrsA( ChkTagGadgets[ GD_CT_Und ], ChkTagWnd,
  2919.                 NULL, (struct TagItem *)CheckedTag );
  2920.  
  2921.     CheckedTag[1] = ( gad->g_Flags & NG_HIGHLABEL ) ? TRUE : FALSE;
  2922.     GT_SetGadgetAttrsA( ChkTagGadgets[ GD_CT_High ], ChkTagWnd,
  2923.                 NULL, (struct TagItem *)CheckedTag );
  2924.  
  2925.     CheckedTag[1] = ( gad->g_Tags & 2 ) ? TRUE : FALSE;
  2926.     GT_SetGadgetAttrsA( ChkTagGadgets[ GD_CT_Disab ], ChkTagWnd,
  2927.                 NULL, (struct TagItem *)CheckedTag );
  2928.  
  2929.     CheckedTag[1] = ( gad->g_Tags & 4 ) ? TRUE : FALSE;
  2930.     GT_SetGadgetAttrsA( ChkTagGadgets[ GD_CT_Chk ], ChkTagWnd,
  2931.                 NULL, (struct TagItem *)CheckedTag );
  2932.  
  2933.     CheckedTag[1] = ( gad->g_Tags & 8 ) ? TRUE : FALSE;
  2934.     GT_SetGadgetAttrsA( ChkTagGadgets[ GD_CT_Scaled ], ChkTagWnd,
  2935.                 NULL, (struct TagItem *)CheckedTag );
  2936.  
  2937.     ActivateGadget( ChkTagGadgets[ GD_CT_Tit ], ChkTagWnd, NULL );
  2938.  
  2939.     if( gad->g_Key )
  2940.         IE.win_info->wi_NumKeys -= 1;
  2941.  
  2942.     buffer4 = (APTR)gad->g_Flags;
  2943.     buffer2 = gad->g_Tags;
  2944.     buffer3 = gad;
  2945.     buffer  = FALSE;
  2946.  
  2947.     while( ReqHandle( ChkTagWnd, HandleChkTagIDCMP ));
  2948.     }
  2949.  
  2950.     CloseChkTagWindow();
  2951. }
  2952.  
  2953. BOOL CT_TitClicked( void )
  2954. {
  2955.     ActivateGadget( ChkTagGadgets[ GD_CT_Label ], ChkTagWnd, NULL );
  2956.     return( TRUE );
  2957. }
  2958.  
  2959. BOOL CT_LabelClicked( void )
  2960. {
  2961.     return( TRUE );
  2962. }
  2963.  
  2964. BOOL ChkTagVanillaKey( void )
  2965. {
  2966.     switch( ChkTagMsg.Code ) {
  2967.     case 13:
  2968.         return( CT_OkClicked() );
  2969.     case 27:
  2970.         return( CT_AnnullaClicked() );
  2971.     }
  2972. }
  2973.  
  2974. BOOL CT_AnnullaKeyPressed( void )
  2975. {
  2976.     return( CT_AnnullaClicked() );
  2977. }
  2978.  
  2979. BOOL CT_AnnullaClicked( void )
  2980. {
  2981.     ((struct GadgetInfo *)buffer3)->g_Flags = buffer4;
  2982.     ((struct GadgetInfo *)buffer3)->g_Tags  = buffer2;
  2983.     return( FALSE );
  2984. }
  2985.  
  2986. BOOL CT_OkKeyPressed( void )
  2987. {
  2988.     return( CT_OkClicked() );
  2989. }
  2990.  
  2991. BOOL CT_OkClicked( void )
  2992. {
  2993.     buffer = TRUE;
  2994.  
  2995.     strcpy( ((struct GadgetInfo *)buffer3)->g_Titolo,
  2996.         GetString( ChkTagGadgets[ GD_CT_Tit ]));
  2997.  
  2998.     STRPTR label;
  2999.  
  3000.     label = GetString( ChkTagGadgets[ GD_CT_Label ]);
  3001.  
  3002.     if( label[0] )
  3003.     strcpy( ((struct GadgetInfo *)buffer3)->g_Label, label );
  3004.  
  3005.     return( FALSE );
  3006. }
  3007.  
  3008. BOOL CT_UndKeyPressed( void )
  3009. {
  3010.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 1 ) ? FALSE : TRUE;
  3011.     GT_SetGadgetAttrsA( ChkTagGadgets[ GD_CT_Und ], ChkTagWnd,
  3012.             NULL, (struct TagItem *)CheckedTag );
  3013.  
  3014.     return( CT_UndClicked() );
  3015. }
  3016.  
  3017. BOOL CT_UndClicked( void )
  3018. {
  3019.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 1;
  3020.     return( TRUE );
  3021. }
  3022.  
  3023. BOOL CT_HighKeyPressed( void )
  3024. {
  3025.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Flags & NG_HIGHLABEL ) ? FALSE : TRUE;
  3026.     GT_SetGadgetAttrsA( ChkTagGadgets[ GD_CT_High ], ChkTagWnd,
  3027.             NULL, (struct TagItem *)CheckedTag );
  3028.  
  3029.     return( CT_HighClicked() );
  3030. }
  3031.  
  3032. BOOL CT_HighClicked( void )
  3033. {
  3034.     ((struct GadgetInfo *)buffer3)->g_Flags ^= NG_HIGHLABEL;
  3035.     return( TRUE );
  3036. }
  3037.  
  3038. BOOL CT_DisabKeyPressed( void )
  3039. {
  3040.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 2 ) ? FALSE : TRUE;
  3041.     GT_SetGadgetAttrsA( ChkTagGadgets[ GD_CT_Disab ], ChkTagWnd,
  3042.             NULL, (struct TagItem *)CheckedTag );
  3043.  
  3044.     return( CT_DisabClicked() );
  3045. }
  3046.  
  3047. BOOL CT_DisabClicked( void )
  3048. {
  3049.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 2;
  3050.     return( TRUE );
  3051. }
  3052.  
  3053. BOOL CT_ChkKeyPressed( void )
  3054. {
  3055.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 4 ) ? FALSE : TRUE;
  3056.     GT_SetGadgetAttrsA( ChkTagGadgets[ GD_CT_Chk ], ChkTagWnd,
  3057.             NULL, (struct TagItem *)CheckedTag );
  3058.  
  3059.     return( CT_ChkClicked() );
  3060. }
  3061.  
  3062. BOOL CT_ChkClicked( void )
  3063. {
  3064.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 4;
  3065.     return( TRUE );
  3066. }
  3067.  
  3068. BOOL CT_ScaledKeyPressed( void )
  3069. {
  3070.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 8 ) ? FALSE : TRUE;
  3071.     GT_SetGadgetAttrsA( ChkTagGadgets[ GD_CT_Scaled ], ChkTagWnd,
  3072.             NULL, (struct TagItem *)CheckedTag );
  3073.  
  3074.     return( CT_ScaledClicked() );
  3075. }
  3076.  
  3077. BOOL CT_ScaledClicked( void )
  3078. {
  3079.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 8;
  3080.     return( TRUE );
  3081. }
  3082.  
  3083. BOOL CT_PosTitKeyPressed( void )
  3084. {
  3085.     if( CycleTag[1] < 5 )
  3086.     CycleTag[1] += 1;
  3087.     else
  3088.     CycleTag[1] = 0;
  3089.  
  3090.     GT_SetGadgetAttrsA( ChkTagGadgets[ GD_CT_PosTit ], ChkTagWnd,
  3091.             NULL, (struct TagItem *)CycleTag );
  3092.  
  3093.     ChkTagMsg.Code = CycleTag[1];
  3094.  
  3095.     return( CT_PosTitClicked() );
  3096. }
  3097.  
  3098. BOOL CT_PosTitClicked( void )
  3099. {
  3100.     ULONG   t;
  3101.  
  3102.     CycleTag[1] = ChkTagMsg.Code;
  3103.  
  3104.     t = ((struct GadgetInfo *)buffer3)->g_Flags & 32;
  3105.     ((struct GadgetInfo *)buffer3)->g_Flags = t | gadget_flags[ ChkTagMsg.Code ];
  3106.  
  3107.     return( TRUE );
  3108. }
  3109. ///
  3110. /// Parametri INTEGER
  3111. void ParametriInteger( struct GadgetInfo *gad )
  3112. {
  3113.     int     ret;
  3114.  
  3115.     LayoutWindow( IntTagWTags );
  3116.     ret = OpenIntTagWindow();
  3117.     PostOpenWindow( IntTagWTags );
  3118.  
  3119.     if( ret ) {
  3120.     DisplayBeep( Scr );
  3121.     } else {
  3122.  
  3123.     StringTag[1] = gad->g_Titolo;
  3124.     GT_SetGadgetAttrsA( IntTagGadgets[ GD_ITg_Tit ], IntTagWnd,
  3125.                 NULL, (struct TagItem *)StringTag );
  3126.  
  3127.     StringTag[1] = gad->g_Label;
  3128.     GT_SetGadgetAttrsA( IntTagGadgets[ GD_ITg_Label ], IntTagWnd,
  3129.                 NULL, (struct TagItem *)StringTag );
  3130.  
  3131.     ret = 0;
  3132.     while((!( gadget_flags[ ret ] & gad->g_Flags )) && ret < 5 )
  3133.         ret += 1;
  3134.  
  3135.     CycleTag[1] = ret;
  3136.     GT_SetGadgetAttrsA( IntTagGadgets[ GD_ITg_PosTit ], IntTagWnd,
  3137.                 NULL, (struct TagItem *)CycleTag );
  3138.  
  3139.     CycleTag2[1] = ((struct IK)(gad->g_Data)).Just;
  3140.     GT_SetGadgetAttrsA( IntTagGadgets[ GD_ITg_Just ], IntTagWnd,
  3141.                 NULL, (struct TagItem *)CycleTag2 );
  3142.  
  3143.     IntegerTag[1] = ((struct IK)(gad->g_Data)).Num;
  3144.     GT_SetGadgetAttrsA( IntTagGadgets[ GD_ITg_Num ], IntTagWnd,
  3145.                 NULL, (struct TagItem *)IntegerTag );
  3146.  
  3147.     IntegerTag[1] = ((struct IK)(gad->g_Data)).MaxC;
  3148.     GT_SetGadgetAttrsA( IntTagGadgets[ GD_ITg_MaxCh ], IntTagWnd,
  3149.                 NULL, (struct TagItem *)IntegerTag );
  3150.  
  3151.     CheckedTag[1] = ( gad->g_Tags & 1 ) ? TRUE : FALSE;
  3152.     GT_SetGadgetAttrsA( IntTagGadgets[ GD_ITg_Und ], IntTagWnd,
  3153.                 NULL, (struct TagItem *)CheckedTag );
  3154.  
  3155.     CheckedTag[1] = ( gad->g_Flags & NG_HIGHLABEL ) ? TRUE : FALSE;
  3156.     GT_SetGadgetAttrsA( IntTagGadgets[ GD_ITg_High ], IntTagWnd,
  3157.                 NULL, (struct TagItem *)CheckedTag );
  3158.  
  3159.     CheckedTag[1] = ( gad->g_Tags & 2 ) ? TRUE : FALSE;
  3160.     GT_SetGadgetAttrsA( IntTagGadgets[ GD_ITg_Disab ], IntTagWnd,
  3161.                 NULL, (struct TagItem *)CheckedTag );
  3162.  
  3163.     CheckedTag[1] = ( gad->g_Tags & 4 ) ? TRUE : FALSE;
  3164.     GT_SetGadgetAttrsA( IntTagGadgets[ GD_ITg_Imm ], IntTagWnd,
  3165.                 NULL, (struct TagItem *)CheckedTag );
  3166.  
  3167.     CheckedTag[1] = ( gad->g_Tags & 8 ) ? TRUE : FALSE;
  3168.     GT_SetGadgetAttrsA( IntTagGadgets[ GD_ITg_Tab ], IntTagWnd,
  3169.                 NULL, (struct TagItem *)CheckedTag );
  3170.  
  3171.     CheckedTag[1] = ( gad->g_Tags & 0x10 ) ? TRUE : FALSE;
  3172.     GT_SetGadgetAttrsA( IntTagGadgets[ GD_ITg_Help ], IntTagWnd,
  3173.                 NULL, (struct TagItem *)CheckedTag );
  3174.  
  3175.     CheckedTag[1] = ( gad->g_Tags & 0x20 ) ? TRUE : FALSE;
  3176.     GT_SetGadgetAttrsA( IntTagGadgets[ GD_ITg_Rep ], IntTagWnd,
  3177.                 NULL, (struct TagItem *)CheckedTag );
  3178.  
  3179.     ActivateGadget( IntTagGadgets[ GD_ITg_Tit ], IntTagWnd, NULL );
  3180.  
  3181.     if( gad->g_Key )
  3182.         IE.win_info->wi_NumKeys -= 1;
  3183.  
  3184.     buffer4 = (APTR)gad->g_Flags;
  3185.     buffer2 = gad->g_Tags;
  3186.     buffer3 = gad;
  3187.     buffer  = FALSE;
  3188.  
  3189.     while( ReqHandle( IntTagWnd, HandleIntTagIDCMP ));
  3190.     }
  3191.  
  3192.     CloseIntTagWindow();
  3193. }
  3194.  
  3195. BOOL ITg_TitClicked( void )
  3196. {
  3197.     ActivateGadget( IntTagGadgets[ GD_ITg_Label ], IntTagWnd, NULL );
  3198.     return( TRUE );
  3199. }
  3200.  
  3201. BOOL ITg_LabelClicked( void )
  3202. {
  3203.     return( TRUE );
  3204. }
  3205.  
  3206. BOOL IntTagVanillaKey( void )
  3207. {
  3208.     switch( IntTagMsg.Code ) {
  3209.     case 13:
  3210.         return( ITg_OkClicked() );
  3211.     case 27:
  3212.         return( ITg_AnnullaClicked() );
  3213.     }
  3214. }
  3215.  
  3216. BOOL ITg_AnnullaKeyPressed( void )
  3217. {
  3218.     return( ITg_AnnullaClicked() );
  3219. }
  3220.  
  3221. BOOL ITg_AnnullaClicked( void )
  3222. {
  3223.     ((struct GadgetInfo *)buffer3)->g_Flags = buffer4;
  3224.     ((struct GadgetInfo *)buffer3)->g_Tags  = buffer2;
  3225.     return( FALSE );
  3226. }
  3227.  
  3228. BOOL ITg_OkKeyPressed( void )
  3229. {
  3230.     return( ITg_OkClicked() );
  3231. }
  3232.  
  3233. BOOL ITg_OkClicked( void )
  3234. {
  3235.     buffer = TRUE;
  3236.  
  3237.     strcpy( ((struct GadgetInfo *)buffer3)->g_Titolo,
  3238.         GetString( IntTagGadgets[ GD_ITg_Tit ]));
  3239.  
  3240.     STRPTR label;
  3241.  
  3242.     label = GetString( IntTagGadgets[ GD_ITg_Label ]);
  3243.  
  3244.     if( label[0] )
  3245.     strcpy( ((struct GadgetInfo *)buffer3)->g_Label, label );
  3246.  
  3247.     ((struct IK)(((struct GadgetInfo *)buffer3)->g_Data)).Num  = GetNumber( IntTagGadgets[ GD_ITg_Num ]);
  3248.     ((struct IK)(((struct GadgetInfo *)buffer3)->g_Data)).MaxC = GetNumber( IntTagGadgets[ GD_ITg_MaxCh ]);
  3249.     ((struct IK)(((struct GadgetInfo *)buffer3)->g_Data)).Just = CycleTag2[1];
  3250.  
  3251.     return( FALSE );
  3252. }
  3253.  
  3254. BOOL ITg_UndKeyPressed( void )
  3255. {
  3256.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 1 ) ? FALSE : TRUE;
  3257.     GT_SetGadgetAttrsA( IntTagGadgets[ GD_ITg_Und ], IntTagWnd,
  3258.             NULL, (struct TagItem *)CheckedTag );
  3259.  
  3260.     return( ITg_UndClicked() );
  3261. }
  3262.  
  3263. BOOL ITg_UndClicked( void )
  3264. {
  3265.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 1;
  3266.     return( TRUE );
  3267. }
  3268.  
  3269. BOOL ITg_HighKeyPressed( void )
  3270. {
  3271.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Flags & NG_HIGHLABEL ) ? FALSE : TRUE;
  3272.     GT_SetGadgetAttrsA( IntTagGadgets[ GD_ITg_High ], IntTagWnd,
  3273.             NULL, (struct TagItem *)CheckedTag );
  3274.  
  3275.     return( ITg_HighClicked() );
  3276. }
  3277.  
  3278. BOOL ITg_HighClicked( void )
  3279. {
  3280.     ((struct GadgetInfo *)buffer3)->g_Flags ^= NG_HIGHLABEL;
  3281.     return( TRUE );
  3282. }
  3283.  
  3284. BOOL ITg_DisabKeyPressed( void )
  3285. {
  3286.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 2 ) ? FALSE : TRUE;
  3287.     GT_SetGadgetAttrsA( IntTagGadgets[ GD_ITg_Disab ], IntTagWnd,
  3288.             NULL, (struct TagItem *)CheckedTag );
  3289.  
  3290.     return( ITg_DisabClicked() );
  3291. }
  3292.  
  3293. BOOL ITg_DisabClicked( void )
  3294. {
  3295.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 2;
  3296.     return( TRUE );
  3297. }
  3298.  
  3299. BOOL ITg_ImmKeyPressed( void )
  3300. {
  3301.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 4 ) ? FALSE : TRUE;
  3302.     GT_SetGadgetAttrsA( IntTagGadgets[ GD_ITg_Imm ], IntTagWnd,
  3303.             NULL, (struct TagItem *)CheckedTag );
  3304.  
  3305.     return( ITg_ImmClicked() );
  3306. }
  3307.  
  3308. BOOL ITg_ImmClicked( void )
  3309. {
  3310.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 4;
  3311.     return( TRUE );
  3312. }
  3313.  
  3314. BOOL ITg_TabKeyPressed( void )
  3315. {
  3316.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 8 ) ? FALSE : TRUE;
  3317.     GT_SetGadgetAttrsA( IntTagGadgets[ GD_ITg_Tab ], IntTagWnd,
  3318.             NULL, (struct TagItem *)CheckedTag );
  3319.  
  3320.     return( ITg_TabClicked() );
  3321. }
  3322.  
  3323. BOOL ITg_TabClicked( void )
  3324. {
  3325.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 8;
  3326.     return( TRUE );
  3327. }
  3328.  
  3329. BOOL ITg_HelpKeyPressed( void )
  3330. {
  3331.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 0x10 ) ? FALSE : TRUE;
  3332.     GT_SetGadgetAttrsA( IntTagGadgets[ GD_ITg_Help ], IntTagWnd,
  3333.             NULL, (struct TagItem *)CheckedTag );
  3334.  
  3335.     return( ITg_HelpClicked() );
  3336. }
  3337.  
  3338. BOOL ITg_HelpClicked( void )
  3339. {
  3340.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 0x10;
  3341.     return( TRUE );
  3342. }
  3343.  
  3344. BOOL ITg_RepKeyPressed( void )
  3345. {
  3346.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 0x20 ) ? FALSE : TRUE;
  3347.     GT_SetGadgetAttrsA( IntTagGadgets[ GD_ITg_Rep ], IntTagWnd,
  3348.             NULL, (struct TagItem *)CheckedTag );
  3349.  
  3350.     return( ITg_RepClicked() );
  3351. }
  3352.  
  3353. BOOL ITg_RepClicked( void )
  3354. {
  3355.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 0x20;
  3356.     return( TRUE );
  3357. }
  3358.  
  3359. BOOL ITg_PosTitKeyPressed( void )
  3360. {
  3361.     if( CycleTag[1] < 5 )
  3362.     CycleTag[1] += 1;
  3363.     else
  3364.     CycleTag[1] = 0;
  3365.  
  3366.     GT_SetGadgetAttrsA( IntTagGadgets[ GD_ITg_PosTit ], IntTagWnd,
  3367.             NULL, (struct TagItem *)CycleTag );
  3368.  
  3369.     IntTagMsg.Code = CycleTag[1];
  3370.  
  3371.     return( ITg_PosTitClicked() );
  3372. }
  3373.  
  3374. BOOL ITg_NumClicked( void )
  3375. {
  3376.     ActivateGadget( IntTagGadgets[ GD_ITg_MaxCh ], IntTagWnd, NULL );
  3377.     return( TRUE );
  3378. }
  3379.  
  3380. BOOL ITg_JustKeyPressed( void )
  3381. {
  3382.     if( CycleTag2[1] < 2 )
  3383.     CycleTag2[1] += 1;
  3384.     else
  3385.     CycleTag2[1] = 0;
  3386.  
  3387.     GT_SetGadgetAttrsA( IntTagGadgets[ GD_ITg_Just ], IntTagWnd,
  3388.             NULL, (struct TagItem *)CycleTag2 );
  3389.  
  3390.     return( TRUE );
  3391. }
  3392.  
  3393. BOOL ITg_JustClicked( void )
  3394. {
  3395.     CycleTag2[1] = IntTagMsg.Code;
  3396.     return( TRUE );
  3397. }
  3398.  
  3399. BOOL ITg_MaxChClicked( void )
  3400. {
  3401.     return( TRUE );
  3402. }
  3403.  
  3404. BOOL ITg_PosTitClicked( void )
  3405. {
  3406.     ULONG   t;
  3407.  
  3408.     CycleTag[1] = IntTagMsg.Code;
  3409.  
  3410.     t = ((struct GadgetInfo *)buffer3)->g_Flags & 32;
  3411.     ((struct GadgetInfo *)buffer3)->g_Flags = t | gadget_flags[ IntTagMsg.Code ];
  3412.  
  3413.     return( TRUE );
  3414. }
  3415. ///
  3416. /// Parametri LISTVIEW
  3417.  
  3418. #define gd ((struct LK)(((struct GadgetInfo *)buffer3)->g_Data))
  3419.  
  3420. void ParametriListview( struct GadgetInfo *gad )
  3421. {
  3422.     int     ret;
  3423.  
  3424.     LayoutWindow( LstTagWTags );
  3425.     ret = OpenLstTagWindow();
  3426.     PostOpenWindow( LstTagWTags );
  3427.  
  3428.     if( ret ) {
  3429.     DisplayBeep( Scr );
  3430.     } else {
  3431.  
  3432.     buffer3 = gad;
  3433.  
  3434.     StringTag[1] = gad->g_Titolo;
  3435.     GT_SetGadgetAttrsA( LstTagGadgets[ GD_LT_Tit ], LstTagWnd,
  3436.                 NULL, (struct TagItem *)StringTag );
  3437.  
  3438.     StringTag[1] = gad->g_Label;
  3439.     GT_SetGadgetAttrsA( LstTagGadgets[ GD_LT_Label ], LstTagWnd,
  3440.                 NULL, (struct TagItem *)StringTag );
  3441.  
  3442.     ret = 0;
  3443.     while((!( gadget_flags[ ret ] & gad->g_Flags )) && ret < 5 )
  3444.         ret += 1;
  3445.  
  3446.     CycleTag[1] = ret;
  3447.     GT_SetGadgetAttrsA( LstTagGadgets[ GD_LT_PosTit ], LstTagWnd,
  3448.                 NULL, (struct TagItem *)CycleTag );
  3449.  
  3450.     CheckedTag[1] = ( gad->g_Tags & 1 ) ? TRUE : FALSE;
  3451.     GT_SetGadgetAttrsA( LstTagGadgets[ GD_LT_Und ], LstTagWnd,
  3452.                 NULL, (struct TagItem *)CheckedTag );
  3453.  
  3454.     CheckedTag[1] = ( gad->g_Flags & NG_HIGHLABEL ) ? TRUE : FALSE;
  3455.     GT_SetGadgetAttrsA( LstTagGadgets[ GD_LT_High ], LstTagWnd,
  3456.                 NULL, (struct TagItem *)CheckedTag );
  3457.  
  3458.     CheckedTag[1] = ( gad->g_Tags & 2 ) ? TRUE : FALSE;
  3459.     GT_SetGadgetAttrsA( LstTagGadgets[ GD_LT_Disab ], LstTagWnd,
  3460.                 NULL, (struct TagItem *)CheckedTag );
  3461.  
  3462.     CheckedTag[1] = ( gad->g_Tags & 4 ) ? TRUE : FALSE;
  3463.     GT_SetGadgetAttrsA( LstTagGadgets[ GD_LT_ROn ], LstTagWnd,
  3464.                 NULL, (struct TagItem *)CheckedTag );
  3465.  
  3466.     CheckedTag[1] = ( gad->g_Tags & 8 ) ? TRUE : FALSE;
  3467.     GT_SetGadgetAttrsA( LstTagGadgets[ GD_LT_Show ], LstTagWnd,
  3468.                 NULL, (struct TagItem *)CheckedTag );
  3469.  
  3470.     CheckedTag[1] = gd.MultiSelect;
  3471.     GT_SetGadgetAttrsA( LstTagGadgets[ GD_LT_Multi ], LstTagWnd,
  3472.                 NULL, (struct TagItem *)CheckedTag );
  3473.  
  3474.     if( gd.MultiSelect ) {
  3475.         DisableTag[1] = TRUE;
  3476.         GT_SetGadgetAttrsA( LstTagGadgets[ GD_LT_Sel ], LstTagWnd,
  3477.                 NULL, (struct TagItem *)DisableTag );
  3478.     }
  3479.  
  3480.     IntegerTag[1] = gd.Top;
  3481.     GT_SetGadgetAttrsA( LstTagGadgets[ GD_LT_Top ], LstTagWnd,
  3482.                 NULL, (struct TagItem *)IntegerTag );
  3483.  
  3484.     IntegerTag[1] = gd.Vis;
  3485.     GT_SetGadgetAttrsA( LstTagGadgets[ GD_LT_Vis ], LstTagWnd,
  3486.                 NULL, (struct TagItem *)IntegerTag );
  3487.  
  3488.     IntegerTag[1] = gd.ScW;
  3489.     GT_SetGadgetAttrsA( LstTagGadgets[ GD_LT_ScW ], LstTagWnd,
  3490.                 NULL, (struct TagItem *)IntegerTag );
  3491.  
  3492.     IntegerTag[1] = gd.Sel;
  3493.     GT_SetGadgetAttrsA( LstTagGadgets[ GD_LT_Sel ], LstTagWnd,
  3494.                 NULL, (struct TagItem *)IntegerTag );
  3495.  
  3496.     IntegerTag[1] = gd.Spc;
  3497.     GT_SetGadgetAttrsA( LstTagGadgets[ GD_LT_Spc ], LstTagWnd,
  3498.                 NULL, (struct TagItem *)IntegerTag );
  3499.  
  3500.     IntegerTag[1] = gd.IH;
  3501.     GT_SetGadgetAttrsA( LstTagGadgets[ GD_LT_IH ], LstTagWnd,
  3502.                 NULL, (struct TagItem *)IntegerTag );
  3503.  
  3504.     IntegerTag[1] = gd.MaxP;
  3505.     GT_SetGadgetAttrsA( LstTagGadgets[ GD_LT_MaxP ], LstTagWnd,
  3506.                 NULL, (struct TagItem *)IntegerTag );
  3507.  
  3508.     if( gad->g_Key )
  3509.         IE.win_info->wi_NumKeys -= 1;
  3510.  
  3511.     buffer4     = (APTR)gad->g_Flags;
  3512.     buffer2     = gad->g_Tags;
  3513.     buffer      = FALSE;
  3514.     BackValue   = gd.MultiSelect;
  3515.  
  3516.     ActivateGadget( LstTagGadgets[ GD_LT_Tit ], LstTagWnd, NULL );
  3517.  
  3518.     while( ReqHandle( LstTagWnd, HandleLstTagIDCMP ));
  3519.     }
  3520.  
  3521.     CloseLstTagWindow();
  3522. }
  3523.  
  3524. BOOL LT_TitClicked( void )
  3525. {
  3526.     ActivateGadget( LstTagGadgets[ GD_LT_Label ], LstTagWnd, NULL );
  3527.     return( TRUE );
  3528. }
  3529.  
  3530. BOOL LT_LabelClicked( void )
  3531. {
  3532.     return( TRUE );
  3533. }
  3534.  
  3535. BOOL LstTagVanillaKey( void )
  3536. {
  3537.     switch( LstTagMsg.Code ) {
  3538.     case 13:
  3539.         return( LT_OkClicked() );
  3540.     case 27:
  3541.         return( LT_AnnullaClicked() );
  3542.     }
  3543. }
  3544.  
  3545. BOOL LT_AnnullaKeyPressed( void )
  3546. {
  3547.     return( LT_AnnullaClicked() );
  3548. }
  3549.  
  3550. BOOL LT_AnnullaClicked( void )
  3551. {
  3552.     ((struct GadgetInfo *)buffer3)->g_Flags = buffer4;
  3553.     ((struct GadgetInfo *)buffer3)->g_Tags  = buffer2;
  3554.     return( FALSE );
  3555. }
  3556.  
  3557. BOOL LT_OkKeyPressed( void )
  3558. {
  3559.     return( LT_OkClicked() );
  3560. }
  3561.  
  3562. BOOL LT_OkClicked( void )
  3563. {
  3564.     STRPTR label;
  3565.  
  3566.     buffer = TRUE;
  3567.  
  3568.     strcpy( ((struct GadgetInfo *)buffer3)->g_Titolo,
  3569.         GetString( LstTagGadgets[ GD_LT_Tit ]));
  3570.  
  3571.     label = GetString( LstTagGadgets[ GD_LT_Label ]);
  3572.  
  3573.     if( label[0] )
  3574.     strcpy( ((struct GadgetInfo *)buffer3)->g_Label, label );
  3575.  
  3576.     gd.Top          = GetNumber( LstTagGadgets[ GD_LT_Top  ]);
  3577.     gd.Vis          = GetNumber( LstTagGadgets[ GD_LT_Vis  ]);
  3578.     gd.ScW          = GetNumber( LstTagGadgets[ GD_LT_ScW  ]);
  3579.     gd.Sel          = GetNumber( LstTagGadgets[ GD_LT_Sel  ]);
  3580.     gd.Spc          = GetNumber( LstTagGadgets[ GD_LT_Spc  ]);
  3581.     gd.IH           = GetNumber( LstTagGadgets[ GD_LT_IH   ]);
  3582.     gd.MaxP         = GetNumber( LstTagGadgets[ GD_LT_MaxP ]);
  3583.     gd.MultiSelect  = BackValue;
  3584.  
  3585.     return( FALSE );
  3586. }
  3587.  
  3588. BOOL LT_UndKeyPressed( void )
  3589. {
  3590.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 1 ) ? FALSE : TRUE;
  3591.     GT_SetGadgetAttrsA( LstTagGadgets[ GD_LT_Und ], LstTagWnd,
  3592.             NULL, (struct TagItem *)CheckedTag );
  3593.  
  3594.     return( LT_UndClicked() );
  3595. }
  3596.  
  3597. BOOL LT_UndClicked( void )
  3598. {
  3599.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 1;
  3600.     return( TRUE );
  3601. }
  3602.  
  3603. BOOL LT_HighKeyPressed( void )
  3604. {
  3605.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Flags & NG_HIGHLABEL ) ? FALSE : TRUE;
  3606.     GT_SetGadgetAttrsA( LstTagGadgets[ GD_LT_High ], LstTagWnd,
  3607.             NULL, (struct TagItem *)CheckedTag );
  3608.  
  3609.     return( LT_HighClicked() );
  3610. }
  3611.  
  3612. BOOL LT_HighClicked( void )
  3613. {
  3614.     ((struct GadgetInfo *)buffer3)->g_Flags ^= NG_HIGHLABEL;
  3615.     return( TRUE );
  3616. }
  3617.  
  3618. BOOL LT_DisabKeyPressed( void )
  3619. {
  3620.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 2 ) ? FALSE : TRUE;
  3621.     GT_SetGadgetAttrsA( LstTagGadgets[ GD_LT_Disab ], LstTagWnd,
  3622.             NULL, (struct TagItem *)CheckedTag );
  3623.  
  3624.     return( LT_DisabClicked() );
  3625. }
  3626.  
  3627. BOOL LT_DisabClicked( void )
  3628. {
  3629.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 2;
  3630.     return( TRUE );
  3631. }
  3632.  
  3633. BOOL LT_ROnKeyPressed( void )
  3634. {
  3635.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 4 ) ? FALSE : TRUE;
  3636.     GT_SetGadgetAttrsA( LstTagGadgets[ GD_LT_ROn ], LstTagWnd,
  3637.             NULL, (struct TagItem *)CheckedTag );
  3638.  
  3639.     return( LT_ROnClicked() );
  3640. }
  3641.  
  3642. BOOL LT_ROnClicked( void )
  3643. {
  3644.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 4;
  3645.     return( TRUE );
  3646. }
  3647.  
  3648. BOOL LT_ShowKeyPressed( void )
  3649. {
  3650.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 8 ) ? FALSE : TRUE;
  3651.     GT_SetGadgetAttrsA( LstTagGadgets[ GD_LT_Show ], LstTagWnd,
  3652.             NULL, (struct TagItem *)CheckedTag );
  3653.  
  3654.     return( LT_ShowClicked() );
  3655. }
  3656.  
  3657. BOOL LT_ShowClicked( void )
  3658. {
  3659.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 8;
  3660.     return( TRUE );
  3661. }
  3662.  
  3663. BOOL LT_MultiKeyPressed( void )
  3664. {
  3665.     CheckedTag[1] = LstTagMsg.Code = BackValue ? FALSE : TRUE;
  3666.     GT_SetGadgetAttrsA( LstTagGadgets[ GD_LT_Multi ], LstTagWnd,
  3667.             NULL, (struct TagItem *)CheckedTag );
  3668.  
  3669.     return( LT_MultiClicked() );
  3670. }
  3671.  
  3672. BOOL LT_MultiClicked( void )
  3673. {
  3674.     BackValue = LstTagMsg.Code;
  3675.  
  3676.     DisableTag[1] = BackValue;
  3677.     GT_SetGadgetAttrsA( LstTagGadgets[ GD_LT_Sel ], LstTagWnd,
  3678.             NULL, (struct TagItem *)DisableTag );
  3679.  
  3680.     return( TRUE );
  3681. }
  3682.  
  3683. BOOL LT_PosTitKeyPressed( void )
  3684. {
  3685.     if( CycleTag[1] < 5 )
  3686.     CycleTag[1] += 1;
  3687.     else
  3688.     CycleTag[1] = 0;
  3689.  
  3690.     GT_SetGadgetAttrsA( LstTagGadgets[ GD_LT_PosTit ], LstTagWnd,
  3691.             NULL, (struct TagItem *)CycleTag );
  3692.  
  3693.     LstTagMsg.Code = CycleTag[1];
  3694.  
  3695.     return( LT_PosTitClicked() );
  3696. }
  3697.  
  3698. BOOL LT_TopClicked( void )
  3699. {
  3700.     ActivateGadget( LstTagGadgets[ GD_LT_Vis ], LstTagWnd, NULL );
  3701.     return( TRUE );
  3702. }
  3703.  
  3704. BOOL LT_VisClicked( void )
  3705. {
  3706.     ActivateGadget( LstTagGadgets[ GD_LT_Sel ], LstTagWnd, NULL );
  3707.     return( TRUE );
  3708. }
  3709.  
  3710. BOOL LT_SelClicked( void )
  3711. {
  3712.     ActivateGadget( LstTagGadgets[ GD_LT_ScW ], LstTagWnd, NULL );
  3713.     return( TRUE );
  3714. }
  3715.  
  3716. BOOL LT_ScWClicked( void )
  3717. {
  3718.     ActivateGadget( LstTagGadgets[ GD_LT_Spc ], LstTagWnd, NULL );
  3719.     return( TRUE );
  3720. }
  3721.  
  3722. BOOL LT_SpcClicked( void )
  3723. {
  3724.     ActivateGadget( LstTagGadgets[ GD_LT_IH ], LstTagWnd, NULL );
  3725.     return( TRUE );
  3726. }
  3727.  
  3728. BOOL LT_IHClicked( void )
  3729. {
  3730.     ActivateGadget( LstTagGadgets[ GD_LT_MaxP ], LstTagWnd, NULL );
  3731.     return( TRUE );
  3732. }
  3733.  
  3734. BOOL LT_MaxPClicked( void )
  3735. {
  3736.     return( TRUE );
  3737. }
  3738.  
  3739. BOOL LT_PosTitClicked( void )
  3740. {
  3741.     ULONG   t;
  3742.  
  3743.     CycleTag[1] = LstTagMsg.Code;
  3744.  
  3745.     t = ((struct GadgetInfo *)buffer3)->g_Flags & 32;
  3746.     ((struct GadgetInfo *)buffer3)->g_Flags = t | gadget_flags[ LstTagMsg.Code ];
  3747.  
  3748.     return( TRUE );
  3749. }
  3750.  
  3751. #undef gd
  3752. ///
  3753. /// Parametri MX
  3754. #define gd ((struct MK)(((struct GadgetInfo *)buffer3)->g_Data))
  3755.  
  3756. void ParametriMx( struct GadgetInfo *gad )
  3757. {
  3758.     int     ret;
  3759.  
  3760.     LayoutWindow( MxTagWTags );
  3761.     ret = OpenMxTagWindow();
  3762.     PostOpenWindow( MxTagWTags );
  3763.  
  3764.     if( ret ) {
  3765.     DisplayBeep( Scr );
  3766.     } else {
  3767.  
  3768.     buffer3 = gad;
  3769.  
  3770.     StringTag[1] = gad->g_Titolo;
  3771.     GT_SetGadgetAttrsA( MxTagGadgets[ GD_MT_Tit ], MxTagWnd,
  3772.                 NULL, (struct TagItem *)StringTag );
  3773.  
  3774.     StringTag[1] = gad->g_Label;
  3775.     GT_SetGadgetAttrsA( MxTagGadgets[ GD_MT_Label ], MxTagWnd,
  3776.                 NULL, (struct TagItem *)StringTag );
  3777.  
  3778.     ret = 0;
  3779.     while((!( gadget_flags[ ret ] & gad->g_Flags )) && ret < 5 )
  3780.         ret += 1;
  3781.  
  3782.     CycleTag[1] = ret;
  3783.     GT_SetGadgetAttrsA( MxTagGadgets[ GD_MT_PosTit ], MxTagWnd,
  3784.                 NULL, (struct TagItem *)CycleTag );
  3785.  
  3786.     CycleTag2[1] = gd.TitPlc;
  3787.     GT_SetGadgetAttrsA( MxTagGadgets[ GD_MT_TitPlc ], MxTagWnd,
  3788.                 NULL, (struct TagItem *)CycleTag2 );
  3789.  
  3790.     CheckedTag[1] = ( gad->g_Tags & 1 ) ? TRUE : FALSE;
  3791.     GT_SetGadgetAttrsA( MxTagGadgets[ GD_MT_Und ], MxTagWnd,
  3792.                 NULL, (struct TagItem *)CheckedTag );
  3793.  
  3794.     CheckedTag[1] = ( gad->g_Flags & NG_HIGHLABEL ) ? TRUE : FALSE;
  3795.     GT_SetGadgetAttrsA( MxTagGadgets[ GD_MT_High ], MxTagWnd,
  3796.                 NULL, (struct TagItem *)CheckedTag );
  3797.  
  3798.     CheckedTag[1] = ( gad->g_Tags & 2 ) ? TRUE : FALSE;
  3799.     GT_SetGadgetAttrsA( MxTagGadgets[ GD_MT_Disab ], MxTagWnd,
  3800.                 NULL, (struct TagItem *)CheckedTag );
  3801.  
  3802.     CheckedTag[1] = ( gad->g_Tags & 4 ) ? TRUE : FALSE;
  3803.     GT_SetGadgetAttrsA( MxTagGadgets[ GD_MT_Scaled ], MxTagWnd,
  3804.                 NULL, (struct TagItem *)CheckedTag );
  3805.  
  3806.     IntegerTag[1] = gd.Act;
  3807.     GT_SetGadgetAttrsA( MxTagGadgets[ GD_MT_Act ], MxTagWnd,
  3808.                 NULL, (struct TagItem *)IntegerTag );
  3809.  
  3810.     IntegerTag[1] = gd.Spc;
  3811.     GT_SetGadgetAttrsA( MxTagGadgets[ GD_MT_Spc ], MxTagWnd,
  3812.                 NULL, (struct TagItem *)IntegerTag );
  3813.  
  3814.     ActivateGadget( MxTagGadgets[ GD_MT_Tit ], MxTagWnd, NULL );
  3815.  
  3816.     if( gad->g_Key )
  3817.         IE.win_info->wi_NumKeys -= 1;
  3818.  
  3819.     buffer4 = (APTR)gad->g_Flags;
  3820.     buffer2 = gad->g_Tags;
  3821.     buffer  = FALSE;
  3822.  
  3823.     while( ReqHandle( MxTagWnd, HandleMxTagIDCMP ));
  3824.     }
  3825.  
  3826.     CloseMxTagWindow();
  3827. }
  3828.  
  3829. BOOL MT_TitClicked( void )
  3830. {
  3831.     ActivateGadget( MxTagGadgets[ GD_MT_Label ], MxTagWnd, NULL );
  3832.     return( TRUE );
  3833. }
  3834.  
  3835. BOOL MT_LabelClicked( void )
  3836. {
  3837.     return( TRUE );
  3838. }
  3839.  
  3840. BOOL MxTagVanillaKey( void )
  3841. {
  3842.     switch( MxTagMsg.Code ) {
  3843.     case 13:
  3844.         return( MT_OkClicked() );
  3845.     case 27:
  3846.         return( MT_AnnullaClicked() );
  3847.     }
  3848. }
  3849.  
  3850. BOOL MT_AnnullaKeyPressed( void )
  3851. {
  3852.     return( MT_AnnullaClicked() );
  3853. }
  3854.  
  3855. BOOL MT_AnnullaClicked( void )
  3856. {
  3857.     ((struct GadgetInfo *)buffer3)->g_Flags = buffer4;
  3858.     ((struct GadgetInfo *)buffer3)->g_Tags  = buffer2;
  3859.     return( FALSE );
  3860. }
  3861.  
  3862. BOOL MT_OkKeyPressed( void )
  3863. {
  3864.     return( MT_OkClicked() );
  3865. }
  3866.  
  3867. BOOL MT_OkClicked( void )
  3868. {
  3869.     buffer = TRUE;
  3870.  
  3871.     strcpy( ((struct GadgetInfo *)buffer3)->g_Titolo,
  3872.         GetString( MxTagGadgets[ GD_MT_Tit ]));
  3873.  
  3874.     STRPTR label;
  3875.  
  3876.     label = GetString( MxTagGadgets[ GD_MT_Label ]);
  3877.  
  3878.     if( label[0] )
  3879.     strcpy( ((struct GadgetInfo *)buffer3)->g_Label, label );
  3880.  
  3881.     gd.Act    = GetNumber( MxTagGadgets[ GD_MT_Act ]);
  3882.     gd.Spc    = GetNumber( MxTagGadgets[ GD_MT_Spc ]);
  3883.     gd.TitPlc = CycleTag2[1];
  3884.  
  3885.     return( FALSE );
  3886. }
  3887.  
  3888. BOOL MT_UndKeyPressed( void )
  3889. {
  3890.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 1 ) ? FALSE : TRUE;
  3891.     GT_SetGadgetAttrsA( MxTagGadgets[ GD_MT_Und ], MxTagWnd,
  3892.             NULL, (struct TagItem *)CheckedTag );
  3893.  
  3894.     return( MT_UndClicked() );
  3895. }
  3896.  
  3897. BOOL MT_UndClicked( void )
  3898. {
  3899.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 1;
  3900.     return( TRUE );
  3901. }
  3902.  
  3903. BOOL MT_HighKeyPressed( void )
  3904. {
  3905.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Flags & NG_HIGHLABEL ) ? FALSE : TRUE;
  3906.     GT_SetGadgetAttrsA( MxTagGadgets[ GD_MT_High ], MxTagWnd,
  3907.             NULL, (struct TagItem *)CheckedTag );
  3908.  
  3909.     return( MT_HighClicked() );
  3910. }
  3911.  
  3912. BOOL MT_HighClicked( void )
  3913. {
  3914.     ((struct GadgetInfo *)buffer3)->g_Flags ^= NG_HIGHLABEL;
  3915.     return( TRUE );
  3916. }
  3917.  
  3918. BOOL MT_DisabKeyPressed( void )
  3919. {
  3920.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 2 ) ? FALSE : TRUE;
  3921.     GT_SetGadgetAttrsA( MxTagGadgets[ GD_MT_Disab ], MxTagWnd,
  3922.             NULL, (struct TagItem *)CheckedTag );
  3923.  
  3924.     return( MT_DisabClicked() );
  3925. }
  3926.  
  3927. BOOL MT_DisabClicked( void )
  3928. {
  3929.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 2;
  3930.     return( TRUE );
  3931. }
  3932.  
  3933. BOOL MT_ScaledKeyPressed( void )
  3934. {
  3935.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 4 ) ? FALSE : TRUE;
  3936.     GT_SetGadgetAttrsA( MxTagGadgets[ GD_MT_Scaled ], MxTagWnd,
  3937.             NULL, (struct TagItem *)CheckedTag );
  3938.  
  3939.     return( MT_ScaledClicked() );
  3940. }
  3941.  
  3942. BOOL MT_ScaledClicked( void )
  3943. {
  3944.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 4;
  3945.     return( TRUE );
  3946. }
  3947.  
  3948. BOOL MT_ActClicked( void )
  3949. {
  3950.     ActivateGadget( MxTagGadgets[ GD_MT_Spc ], MxTagWnd, NULL );
  3951.     return( TRUE );
  3952. }
  3953.  
  3954. BOOL MT_SpcClicked( void )
  3955. {
  3956.     return( TRUE );
  3957. }
  3958.  
  3959. BOOL MT_PosTitKeyPressed( void )
  3960. {
  3961.     if( CycleTag[1] < 5 )
  3962.     CycleTag[1] += 1;
  3963.     else
  3964.     CycleTag[1] = 0;
  3965.  
  3966.     GT_SetGadgetAttrsA( MxTagGadgets[ GD_MT_PosTit ], MxTagWnd,
  3967.             NULL, (struct TagItem *)CycleTag );
  3968.  
  3969.     MxTagMsg.Code = CycleTag[1];
  3970.  
  3971.     return( MT_PosTitClicked() );
  3972. }
  3973.  
  3974. BOOL MT_PosTitClicked( void )
  3975. {
  3976.     ULONG   t;
  3977.  
  3978.     CycleTag[1] = MxTagMsg.Code;
  3979.  
  3980.     t = ((struct GadgetInfo *)buffer3)->g_Flags & 32;
  3981.     ((struct GadgetInfo *)buffer3)->g_Flags = t | gadget_flags[ MxTagMsg.Code ];
  3982.  
  3983.     return( TRUE );
  3984. }
  3985.  
  3986. BOOL MT_TitPlcKeyPressed( void )
  3987. {
  3988.     if( CycleTag2[1] < 3 )
  3989.     CycleTag2[1] += 1;
  3990.     else
  3991.     CycleTag2[1] = 0;
  3992.  
  3993.     GT_SetGadgetAttrsA( MxTagGadgets[ GD_MT_TitPlc ], MxTagWnd,
  3994.             NULL, (struct TagItem *)CycleTag2 );
  3995.  
  3996.     return( TRUE );
  3997. }
  3998.  
  3999. BOOL MT_TitPlcClicked( void )
  4000. {
  4001.     CycleTag2[1] = MxTagMsg.Code;
  4002.  
  4003.     return( TRUE );
  4004. }
  4005.  
  4006. #undef gd
  4007. ///
  4008. /// Parametri NUMBER
  4009. #define gd ((struct NK)(((struct GadgetInfo *)buffer3)->g_Data))
  4010.  
  4011. void ParametriNumber( struct GadgetInfo *gad )
  4012. {
  4013.     int     ret;
  4014.  
  4015.     LayoutWindow( NumTagWTags );
  4016.     ret = OpenNumTagWindow();
  4017.     PostOpenWindow( NumTagWTags );
  4018.  
  4019.     if( ret ) {
  4020.     DisplayBeep( Scr );
  4021.     } else {
  4022.  
  4023.     buffer3 = gad;
  4024.  
  4025.     StringTag[1] = gad->g_Titolo;
  4026.     GT_SetGadgetAttrsA( NumTagGadgets[ GD_NT_Tit ], NumTagWnd,
  4027.                 NULL, (struct TagItem *)StringTag );
  4028.  
  4029.     StringTag[1] = gad->g_Label;
  4030.     GT_SetGadgetAttrsA( NumTagGadgets[ GD_NT_Label ], NumTagWnd,
  4031.                 NULL, (struct TagItem *)StringTag );
  4032.  
  4033.     ret = 0;
  4034.     while((!( gadget_flags[ ret ] & gad->g_Flags )) && ret < 5 )
  4035.         ret += 1;
  4036.  
  4037.     CycleTag[1] = ret;
  4038.     GT_SetGadgetAttrsA( NumTagGadgets[ GD_NT_PosTit ], NumTagWnd,
  4039.                 NULL, (struct TagItem *)CycleTag );
  4040.  
  4041.     CycleTag2[1] = gd.Just;
  4042.     GT_SetGadgetAttrsA( NumTagGadgets[ GD_NT_Just ], NumTagWnd,
  4043.                 NULL, (struct TagItem *)CycleTag2 );
  4044.  
  4045.     CheckedTag[1] = ( gad->g_Tags & 1 ) ? TRUE : FALSE;
  4046.     GT_SetGadgetAttrsA( NumTagGadgets[ GD_NT_Und ], NumTagWnd,
  4047.                 NULL, (struct TagItem *)CheckedTag );
  4048.  
  4049.     CheckedTag[1] = ( gad->g_Flags & NG_HIGHLABEL ) ? TRUE : FALSE;
  4050.     GT_SetGadgetAttrsA( NumTagGadgets[ GD_NT_High ], NumTagWnd,
  4051.                 NULL, (struct TagItem *)CheckedTag );
  4052.  
  4053.     CheckedTag[1] = ( gad->g_Tags & 2 ) ? TRUE : FALSE;
  4054.     GT_SetGadgetAttrsA( NumTagGadgets[ GD_NT_Border ], NumTagWnd,
  4055.                 NULL, (struct TagItem *)CheckedTag );
  4056.  
  4057.     CheckedTag[1] = ( gad->g_Tags & 4 ) ? TRUE : FALSE;
  4058.     GT_SetGadgetAttrsA( NumTagGadgets[ GD_NT_Clip ], NumTagWnd,
  4059.                 NULL, (struct TagItem *)CheckedTag );
  4060.  
  4061.     IntegerTag[1] = gd.Num;
  4062.     GT_SetGadgetAttrsA( NumTagGadgets[ GD_NT_Num ], NumTagWnd,
  4063.                 NULL, (struct TagItem *)IntegerTag );
  4064.  
  4065.     IntegerTag[1] = gd.MNL;
  4066.     GT_SetGadgetAttrsA( NumTagGadgets[ GD_NT_MNL ], NumTagWnd,
  4067.                 NULL, (struct TagItem *)IntegerTag );
  4068.  
  4069.     IntegerTag[1] = gd.FPen;
  4070.     GT_SetGadgetAttrsA( NumTagGadgets[ GD_NT_FPen ], NumTagWnd,
  4071.                 NULL, (struct TagItem *)IntegerTag );
  4072.  
  4073.     IntegerTag[1] = gd.BPen;
  4074.     GT_SetGadgetAttrsA( NumTagGadgets[ GD_NT_BPen ], NumTagWnd,
  4075.                 NULL, (struct TagItem *)IntegerTag );
  4076.  
  4077.     StringTag[1] = gd.Format;
  4078.     GT_SetGadgetAttrsA( NumTagGadgets[ GD_NT_Format ], NumTagWnd,
  4079.                 NULL, (struct TagItem *)StringTag );
  4080.  
  4081.     ActivateGadget( NumTagGadgets[ GD_NT_Tit ], NumTagWnd, NULL );
  4082.  
  4083.     if( gad->g_Key )
  4084.         IE.win_info->wi_NumKeys -= 1;
  4085.  
  4086.     buffer4 = (APTR)gad->g_Flags;
  4087.     buffer2 = gad->g_Tags;
  4088.     buffer  = FALSE;
  4089.  
  4090.     while( ReqHandle( NumTagWnd, HandleNumTagIDCMP ));
  4091.     }
  4092.  
  4093.     CloseNumTagWindow();
  4094. }
  4095.  
  4096. BOOL NT_TitClicked( void )
  4097. {
  4098.     ActivateGadget( NumTagGadgets[ GD_NT_Label ], NumTagWnd, NULL );
  4099.     return( TRUE );
  4100. }
  4101.  
  4102. BOOL NT_LabelClicked( void )
  4103. {
  4104.     return( TRUE );
  4105. }
  4106.  
  4107. BOOL NumTagVanillaKey( void )
  4108. {
  4109.     switch( NumTagMsg.Code ) {
  4110.     case 13:
  4111.         return( NT_OkClicked() );
  4112.     case 27:
  4113.         return( NT_AnnullaClicked() );
  4114.     }
  4115. }
  4116.  
  4117. BOOL NT_AnnullaKeyPressed( void )
  4118. {
  4119.     return( NT_AnnullaClicked() );
  4120. }
  4121.  
  4122. BOOL NT_AnnullaClicked( void )
  4123. {
  4124.     ((struct GadgetInfo *)buffer3)->g_Flags = buffer4;
  4125.     ((struct GadgetInfo *)buffer3)->g_Tags  = buffer2;
  4126.     return( FALSE );
  4127. }
  4128.  
  4129. BOOL NT_OkKeyPressed( void )
  4130. {
  4131.     return( NT_OkClicked() );
  4132. }
  4133.  
  4134. BOOL NT_OkClicked( void )
  4135. {
  4136.     buffer = TRUE;
  4137.  
  4138.     strcpy( ((struct GadgetInfo *)buffer3)->g_Titolo,
  4139.         GetString( NumTagGadgets[ GD_NT_Tit ]));
  4140.  
  4141.     STRPTR label;
  4142.  
  4143.     label = GetString( NumTagGadgets[ GD_NT_Label ]);
  4144.  
  4145.     if( label[0] )
  4146.     strcpy( ((struct GadgetInfo *)buffer3)->g_Label, label );
  4147.  
  4148.     strcpy( gd.Format, GetString( NumTagGadgets[ GD_NT_Format ]));
  4149.  
  4150.     gd.Num  = GetNumber( NumTagGadgets[ GD_NT_Num  ]);
  4151.     gd.FPen = GetNumber( NumTagGadgets[ GD_NT_FPen ]);
  4152.     gd.BPen = GetNumber( NumTagGadgets[ GD_NT_BPen ]);
  4153.     gd.Just = CycleTag2[1];
  4154.     gd.MNL  = GetNumber( NumTagGadgets[ GD_NT_MNL  ]);
  4155.  
  4156.     return( FALSE );
  4157. }
  4158.  
  4159. BOOL NT_UndKeyPressed( void )
  4160. {
  4161.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 1 ) ? FALSE : TRUE;
  4162.     GT_SetGadgetAttrsA( NumTagGadgets[ GD_NT_Und ], NumTagWnd,
  4163.             NULL, (struct TagItem *)CheckedTag );
  4164.  
  4165.     return( NT_UndClicked() );
  4166. }
  4167.  
  4168. BOOL NT_UndClicked( void )
  4169. {
  4170.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 1;
  4171.     return( TRUE );
  4172. }
  4173.  
  4174. BOOL NT_HighKeyPressed( void )
  4175. {
  4176.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Flags & NG_HIGHLABEL ) ? FALSE : TRUE;
  4177.     GT_SetGadgetAttrsA( NumTagGadgets[ GD_NT_High ], NumTagWnd,
  4178.             NULL, (struct TagItem *)CheckedTag );
  4179.  
  4180.     return( NT_HighClicked() );
  4181. }
  4182.  
  4183. BOOL NT_HighClicked( void )
  4184. {
  4185.     ((struct GadgetInfo *)buffer3)->g_Flags ^= NG_HIGHLABEL;
  4186.     return( TRUE );
  4187. }
  4188.  
  4189. BOOL NT_BorderKeyPressed( void )
  4190. {
  4191.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 2 ) ? FALSE : TRUE;
  4192.     GT_SetGadgetAttrsA( NumTagGadgets[ GD_NT_Border ], NumTagWnd,
  4193.             NULL, (struct TagItem *)CheckedTag );
  4194.  
  4195.     return( NT_BorderClicked() );
  4196. }
  4197.  
  4198. BOOL NT_BorderClicked( void )
  4199. {
  4200.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 2;
  4201.     return( TRUE );
  4202. }
  4203.  
  4204. BOOL NT_ClipKeyPressed( void )
  4205. {
  4206.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 4 ) ? FALSE : TRUE;
  4207.     GT_SetGadgetAttrsA( NumTagGadgets[ GD_NT_Clip ], NumTagWnd,
  4208.             NULL, (struct TagItem *)CheckedTag );
  4209.  
  4210.     return( NT_ClipClicked() );
  4211. }
  4212.  
  4213. BOOL NT_ClipClicked( void )
  4214. {
  4215.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 4;
  4216.     return( TRUE );
  4217. }
  4218.  
  4219. BOOL NT_NumClicked( void )
  4220. {
  4221.     ActivateGadget( NumTagGadgets[ GD_NT_MNL ], NumTagWnd, NULL );
  4222.     return( TRUE );
  4223. }
  4224.  
  4225. BOOL NT_MNLClicked( void )
  4226. {
  4227.     ActivateGadget( NumTagGadgets[ GD_NT_FPen ], NumTagWnd, NULL );
  4228.     return( TRUE );
  4229. }
  4230.  
  4231. BOOL NT_FPenClicked( void )
  4232. {
  4233.     ActivateGadget( NumTagGadgets[ GD_NT_BPen ], NumTagWnd, NULL );
  4234.     return( TRUE );
  4235. }
  4236.  
  4237. BOOL NT_BPenClicked( void )
  4238. {
  4239.     return( TRUE );
  4240. }
  4241.  
  4242. BOOL NT_FormatClicked( void )
  4243. {
  4244.     return( TRUE );
  4245. }
  4246.  
  4247. BOOL NT_PosTitKeyPressed( void )
  4248. {
  4249.     if( CycleTag[1] < 5 )
  4250.     CycleTag[1] += 1;
  4251.     else
  4252.     CycleTag[1] = 0;
  4253.  
  4254.     GT_SetGadgetAttrsA( NumTagGadgets[ GD_NT_PosTit ], NumTagWnd,
  4255.             NULL, (struct TagItem *)CycleTag );
  4256.  
  4257.     NumTagMsg.Code = CycleTag[1];
  4258.  
  4259.     return( NT_PosTitClicked() );
  4260. }
  4261.  
  4262. BOOL NT_PosTitClicked( void )
  4263. {
  4264.     ULONG   t;
  4265.  
  4266.     CycleTag[1] = NumTagMsg.Code;
  4267.  
  4268.     t = ((struct GadgetInfo *)buffer3)->g_Flags & 32;
  4269.     ((struct GadgetInfo *)buffer3)->g_Flags = t | gadget_flags[ NumTagMsg.Code ];
  4270.  
  4271.     return( TRUE );
  4272. }
  4273.  
  4274. BOOL NT_JustKeyPressed( void )
  4275. {
  4276.     if( CycleTag2[1] < 2 )
  4277.     CycleTag2[1] += 1;
  4278.     else
  4279.     CycleTag2[1] = 0;
  4280.  
  4281.     GT_SetGadgetAttrsA( NumTagGadgets[ GD_NT_Just ], NumTagWnd,
  4282.             NULL, (struct TagItem *)CycleTag2 );
  4283.  
  4284.     return( TRUE );
  4285. }
  4286.  
  4287. BOOL NT_JustClicked( void )
  4288. {
  4289.     CycleTag2[1] = NumTagMsg.Code;
  4290.  
  4291.     return( TRUE );
  4292. }
  4293.  
  4294. #undef gd
  4295. ///
  4296. /// Parametri CYCLE
  4297. #define gd ((struct CK)(((struct GadgetInfo *)buffer3)->g_Data))
  4298.  
  4299. void ParametriCycle( struct GadgetInfo *gad )
  4300. {
  4301.     int     ret;
  4302.  
  4303.     LayoutWindow( CycTagWTags );
  4304.     ret = OpenCycTagWindow();
  4305.     PostOpenWindow( CycTagWTags );
  4306.  
  4307.     if( ret ) {
  4308.     DisplayBeep( Scr );
  4309.     } else {
  4310.  
  4311.     buffer3 = gad;
  4312.  
  4313.     StringTag[1] = gad->g_Titolo;
  4314.     GT_SetGadgetAttrsA( CycTagGadgets[ GD_CyT_Tit ], CycTagWnd,
  4315.                 NULL, (struct TagItem *)StringTag );
  4316.  
  4317.     StringTag[1] = gad->g_Label;
  4318.     GT_SetGadgetAttrsA( CycTagGadgets[ GD_CyT_Label ], CycTagWnd,
  4319.                 NULL, (struct TagItem *)StringTag );
  4320.  
  4321.     ret = 0;
  4322.     while((!( gadget_flags[ ret ] & gad->g_Flags )) && ret < 5 )
  4323.         ret += 1;
  4324.  
  4325.     CycleTag[1] = ret;
  4326.     GT_SetGadgetAttrsA( CycTagGadgets[ GD_CyT_PosTit ], CycTagWnd,
  4327.                 NULL, (struct TagItem *)CycleTag );
  4328.  
  4329.     CheckedTag[1] = ( gad->g_Tags & 1 ) ? TRUE : FALSE;
  4330.     GT_SetGadgetAttrsA( CycTagGadgets[ GD_CyT_Und ], CycTagWnd,
  4331.                 NULL, (struct TagItem *)CheckedTag );
  4332.  
  4333.     CheckedTag[1] = ( gad->g_Flags & NG_HIGHLABEL ) ? TRUE : FALSE;
  4334.     GT_SetGadgetAttrsA( CycTagGadgets[ GD_CyT_High ], CycTagWnd,
  4335.                 NULL, (struct TagItem *)CheckedTag );
  4336.  
  4337.     CheckedTag[1] = ( gad->g_Tags & 2 ) ? TRUE : FALSE;
  4338.     GT_SetGadgetAttrsA( CycTagGadgets[ GD_CyT_Disab ], CycTagWnd,
  4339.                 NULL, (struct TagItem *)CheckedTag );
  4340.  
  4341.     IntegerTag[1] = gd.Act;
  4342.     GT_SetGadgetAttrsA( CycTagGadgets[ GD_CyT_Act ], CycTagWnd,
  4343.                 NULL, (struct TagItem *)IntegerTag );
  4344.  
  4345.     ActivateGadget( CycTagGadgets[ GD_CyT_Tit ], CycTagWnd, NULL );
  4346.  
  4347.     if( gad->g_Key )
  4348.         IE.win_info->wi_NumKeys -= 1;
  4349.  
  4350.     buffer4 = (APTR)gad->g_Flags;
  4351.     buffer2 = gad->g_Tags;
  4352.     buffer  = FALSE;
  4353.  
  4354.     while( ReqHandle( CycTagWnd, HandleCycTagIDCMP ));
  4355.     }
  4356.  
  4357.     CloseCycTagWindow();
  4358. }
  4359.  
  4360. BOOL CyT_TitClicked( void )
  4361. {
  4362.     ActivateGadget( CycTagGadgets[ GD_CyT_Label ], CycTagWnd, NULL );
  4363.     return( TRUE );
  4364. }
  4365.  
  4366. BOOL CyT_LabelClicked( void )
  4367. {
  4368.     return( TRUE );
  4369. }
  4370.  
  4371. BOOL CycTagVanillaKey( void )
  4372. {
  4373.     switch( CycTagMsg.Code ) {
  4374.     case 13:
  4375.         return( CyT_OkClicked() );
  4376.     case 27:
  4377.         return( CyT_AnnullaClicked() );
  4378.     }
  4379. }
  4380.  
  4381. BOOL CyT_AnnullaKeyPressed( void )
  4382. {
  4383.     return( CyT_AnnullaClicked() );
  4384. }
  4385.  
  4386. BOOL CyT_AnnullaClicked( void )
  4387. {
  4388.     ((struct GadgetInfo *)buffer3)->g_Flags = buffer4;
  4389.     ((struct GadgetInfo *)buffer3)->g_Tags  = buffer2;
  4390.     return( FALSE );
  4391. }
  4392.  
  4393. BOOL CyT_OkKeyPressed( void )
  4394. {
  4395.     return( CyT_OkClicked() );
  4396. }
  4397.  
  4398. BOOL CyT_OkClicked( void )
  4399. {
  4400.     buffer = TRUE;
  4401.  
  4402.     strcpy( ((struct GadgetInfo *)buffer3)->g_Titolo,
  4403.         GetString( CycTagGadgets[ GD_CyT_Tit ]));
  4404.  
  4405.     STRPTR label;
  4406.  
  4407.     label = GetString( CycTagGadgets[ GD_CyT_Label ]);
  4408.  
  4409.     if( label[0] )
  4410.     strcpy( ((struct GadgetInfo *)buffer3)->g_Label, label );
  4411.  
  4412.     gd.Act  = GetNumber( CycTagGadgets[ GD_CyT_Act ]);
  4413.  
  4414.     return( FALSE );
  4415. }
  4416.  
  4417. BOOL CyT_UndKeyPressed( void )
  4418. {
  4419.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 1 ) ? FALSE : TRUE;
  4420.     GT_SetGadgetAttrsA( CycTagGadgets[ GD_CyT_Und ], CycTagWnd,
  4421.             NULL, (struct TagItem *)CheckedTag );
  4422.  
  4423.     return( CyT_UndClicked() );
  4424. }
  4425.  
  4426. BOOL CyT_UndClicked( void )
  4427. {
  4428.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 1;
  4429.     return( TRUE );
  4430. }
  4431.  
  4432. BOOL CyT_HighKeyPressed( void )
  4433. {
  4434.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Flags & NG_HIGHLABEL ) ? FALSE : TRUE;
  4435.     GT_SetGadgetAttrsA( CycTagGadgets[ GD_CyT_High ], CycTagWnd,
  4436.             NULL, (struct TagItem *)CheckedTag );
  4437.  
  4438.     return( CyT_HighClicked() );
  4439. }
  4440.  
  4441. BOOL CyT_HighClicked( void )
  4442. {
  4443.     ((struct GadgetInfo *)buffer3)->g_Flags ^= NG_HIGHLABEL;
  4444.     return( TRUE );
  4445. }
  4446.  
  4447. BOOL CyT_DisabKeyPressed( void )
  4448. {
  4449.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 2 ) ? FALSE : TRUE;
  4450.     GT_SetGadgetAttrsA( CycTagGadgets[ GD_CyT_Disab ], CycTagWnd,
  4451.             NULL, (struct TagItem *)CheckedTag );
  4452.  
  4453.     return( CyT_DisabClicked() );
  4454. }
  4455.  
  4456. BOOL CyT_DisabClicked( void )
  4457. {
  4458.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 2;
  4459.     return( TRUE );
  4460. }
  4461.  
  4462. BOOL CyT_ActClicked( void )
  4463. {
  4464.     return( TRUE );
  4465. }
  4466.  
  4467. BOOL CyT_PosTitKeyPressed( void )
  4468. {
  4469.     if( CycleTag[1] < 5 )
  4470.     CycleTag[1] += 1;
  4471.     else
  4472.     CycleTag[1] = 0;
  4473.  
  4474.     GT_SetGadgetAttrsA( CycTagGadgets[ GD_CyT_PosTit ], CycTagWnd,
  4475.             NULL, (struct TagItem *)CycleTag );
  4476.  
  4477.     CycTagMsg.Code = CycleTag[1];
  4478.  
  4479.     return( CyT_PosTitClicked() );
  4480. }
  4481.  
  4482. BOOL CyT_PosTitClicked( void )
  4483. {
  4484.     ULONG   t;
  4485.  
  4486.     CycleTag[1] = CycTagMsg.Code;
  4487.  
  4488.     t = ((struct GadgetInfo *)buffer3)->g_Flags & 32;
  4489.     ((struct GadgetInfo *)buffer3)->g_Flags = t | gadget_flags[ CycTagMsg.Code ];
  4490.  
  4491.     return( TRUE );
  4492. }
  4493.  
  4494. #undef gd
  4495. ///
  4496. /// Parametri PALETTE
  4497. #define gd ((struct PK)(((struct GadgetInfo *)buffer3)->g_Data))
  4498.  
  4499. void ParametriPalette( struct GadgetInfo *gad )
  4500. {
  4501.     int     ret;
  4502.  
  4503.     LayoutWindow( PalTagWTags );
  4504.     ret = OpenPalTagWindow();
  4505.     PostOpenWindow( PalTagWTags );
  4506.  
  4507.     if( ret ) {
  4508.     DisplayBeep( Scr );
  4509.     } else {
  4510.  
  4511.     buffer3 = gad;
  4512.  
  4513.     StringTag[1] = gad->g_Titolo;
  4514.     GT_SetGadgetAttrsA( PalTagGadgets[ GD_PT_Tit ], PalTagWnd,
  4515.                 NULL, (struct TagItem *)StringTag );
  4516.  
  4517.     StringTag[1] = gad->g_Label;
  4518.     GT_SetGadgetAttrsA( PalTagGadgets[ GD_PT_Label ], PalTagWnd,
  4519.                 NULL, (struct TagItem *)StringTag );
  4520.  
  4521.     ret = 0;
  4522.     while((!( gadget_flags[ ret ] & gad->g_Flags )) && ret < 5 )
  4523.         ret += 1;
  4524.  
  4525.     CycleTag[1] = ret;
  4526.     GT_SetGadgetAttrsA( PalTagGadgets[ GD_PT_PosTit ], PalTagWnd,
  4527.                 NULL, (struct TagItem *)CycleTag );
  4528.  
  4529.     CheckedTag[1] = ( gad->g_Tags & 1 ) ? TRUE : FALSE;
  4530.     GT_SetGadgetAttrsA( PalTagGadgets[ GD_PT_Und ], PalTagWnd,
  4531.                 NULL, (struct TagItem *)CheckedTag );
  4532.  
  4533.     CheckedTag[1] = ( gad->g_Flags & NG_HIGHLABEL ) ? TRUE : FALSE;
  4534.     GT_SetGadgetAttrsA( PalTagGadgets[ GD_PT_High ], PalTagWnd,
  4535.                 NULL, (struct TagItem *)CheckedTag );
  4536.  
  4537.     CheckedTag[1] = ( gad->g_Tags & 2 ) ? TRUE : FALSE;
  4538.     GT_SetGadgetAttrsA( PalTagGadgets[ GD_PT_Disab ], PalTagWnd,
  4539.                 NULL, (struct TagItem *)CheckedTag );
  4540.  
  4541.     IntegerTag[1] = gd.Depth;
  4542.     GT_SetGadgetAttrsA( PalTagGadgets[ GD_PT_Depth ], PalTagWnd,
  4543.                 NULL, (struct TagItem *)IntegerTag );
  4544.  
  4545.     IntegerTag[1] = gd.Color;
  4546.     GT_SetGadgetAttrsA( PalTagGadgets[ GD_PT_Col ], PalTagWnd,
  4547.                 NULL, (struct TagItem *)IntegerTag );
  4548.  
  4549.     IntegerTag[1] = gd.ColOff;
  4550.     GT_SetGadgetAttrsA( PalTagGadgets[ GD_PT_COff ], PalTagWnd,
  4551.                 NULL, (struct TagItem *)IntegerTag );
  4552.  
  4553.     IntegerTag[1] = gd.NumCol;
  4554.     GT_SetGadgetAttrsA( PalTagGadgets[ GD_PT_NumC ], PalTagWnd,
  4555.                 NULL, (struct TagItem *)IntegerTag );
  4556.  
  4557.     IntegerTag[1] = gd.IW;
  4558.     GT_SetGadgetAttrsA( PalTagGadgets[ GD_PT_IW ], PalTagWnd,
  4559.                 NULL, (struct TagItem *)IntegerTag );
  4560.  
  4561.     IntegerTag[1] = gd.IH;
  4562.     GT_SetGadgetAttrsA( PalTagGadgets[ GD_PT_IH ], PalTagWnd,
  4563.                 NULL, (struct TagItem *)IntegerTag );
  4564.  
  4565.     ActivateGadget( PalTagGadgets[ GD_PT_Tit ], PalTagWnd, NULL );
  4566.  
  4567.     if( gad->g_Key )
  4568.         IE.win_info->wi_NumKeys -= 1;
  4569.  
  4570.     buffer4 = (APTR)gad->g_Flags;
  4571.     buffer2 = gad->g_Tags;
  4572.     buffer  = FALSE;
  4573.  
  4574.     while( ReqHandle( PalTagWnd, HandlePalTagIDCMP ));
  4575.     }
  4576.  
  4577.     ClosePalTagWindow();
  4578. }
  4579.  
  4580. BOOL PT_TitClicked( void )
  4581. {
  4582.     ActivateGadget( PalTagGadgets[ GD_PT_Label ], PalTagWnd, NULL );
  4583.     return( TRUE );
  4584. }
  4585.  
  4586. BOOL PT_LabelClicked( void )
  4587. {
  4588.     return( TRUE );
  4589. }
  4590.  
  4591. BOOL PalTagVanillaKey( void )
  4592. {
  4593.     switch( PalTagMsg.Code ) {
  4594.     case 13:
  4595.         return( PT_OkClicked() );
  4596.     case 27:
  4597.         return( PT_AnnullaClicked() );
  4598.     }
  4599. }
  4600.  
  4601. BOOL PT_AnnullaKeyPressed( void )
  4602. {
  4603.     return( PT_AnnullaClicked() );
  4604. }
  4605.  
  4606. BOOL PT_AnnullaClicked( void )
  4607. {
  4608.     ((struct GadgetInfo *)buffer3)->g_Flags = buffer4;
  4609.     ((struct GadgetInfo *)buffer3)->g_Tags  = buffer2;
  4610.     return( FALSE );
  4611. }
  4612.  
  4613. BOOL PT_OkKeyPressed( void )
  4614. {
  4615.     return( PT_OkClicked() );
  4616. }
  4617.  
  4618. BOOL PT_OkClicked( void )
  4619. {
  4620.     buffer = TRUE;
  4621.  
  4622.     strcpy( ((struct GadgetInfo *)buffer3)->g_Titolo,
  4623.         GetString( PalTagGadgets[ GD_PT_Tit ]));
  4624.  
  4625.     STRPTR label;
  4626.  
  4627.     label = GetString( PalTagGadgets[ GD_PT_Label ]);
  4628.  
  4629.     if( label[0] )
  4630.     strcpy( ((struct GadgetInfo *)buffer3)->g_Label, label );
  4631.  
  4632.     gd.Depth  = GetNumber( PalTagGadgets[ GD_PT_Depth ]);
  4633.     gd.Color  = GetNumber( PalTagGadgets[ GD_PT_Col   ]);
  4634.     gd.ColOff = GetNumber( PalTagGadgets[ GD_PT_COff  ]);
  4635.     gd.NumCol = GetNumber( PalTagGadgets[ GD_PT_NumC  ]);
  4636.     gd.IW     = GetNumber( PalTagGadgets[ GD_PT_IW    ]);
  4637.     gd.IH     = GetNumber( PalTagGadgets[ GD_PT_IH    ]);
  4638.  
  4639.     return( FALSE );
  4640. }
  4641.  
  4642. BOOL PT_UndKeyPressed( void )
  4643. {
  4644.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 1 ) ? FALSE : TRUE;
  4645.     GT_SetGadgetAttrsA( PalTagGadgets[ GD_PT_Und ], PalTagWnd,
  4646.             NULL, (struct TagItem *)CheckedTag );
  4647.  
  4648.     return( PT_UndClicked() );
  4649. }
  4650.  
  4651. BOOL PT_UndClicked( void )
  4652. {
  4653.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 1;
  4654.     return( TRUE );
  4655. }
  4656.  
  4657. BOOL PT_HighKeyPressed( void )
  4658. {
  4659.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Flags & NG_HIGHLABEL ) ? FALSE : TRUE;
  4660.     GT_SetGadgetAttrsA( PalTagGadgets[ GD_PT_High ], PalTagWnd,
  4661.             NULL, (struct TagItem *)CheckedTag );
  4662.  
  4663.     return( PT_HighClicked() );
  4664. }
  4665.  
  4666. BOOL PT_HighClicked( void )
  4667. {
  4668.     ((struct GadgetInfo *)buffer3)->g_Flags ^= NG_HIGHLABEL;
  4669.     return( TRUE );
  4670. }
  4671.  
  4672. BOOL PT_DisabKeyPressed( void )
  4673. {
  4674.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 2 ) ? FALSE : TRUE;
  4675.     GT_SetGadgetAttrsA( PalTagGadgets[ GD_PT_Disab ], PalTagWnd,
  4676.             NULL, (struct TagItem *)CheckedTag );
  4677.  
  4678.     return( PT_DisabClicked() );
  4679. }
  4680.  
  4681. BOOL PT_DisabClicked( void )
  4682. {
  4683.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 2;
  4684.     return( TRUE );
  4685. }
  4686.  
  4687. BOOL PT_DepthClicked( void )
  4688. {
  4689.     ActivateGadget( PalTagGadgets[ GD_PT_Col ], PalTagWnd, NULL );
  4690.     return( TRUE );
  4691. }
  4692.  
  4693. BOOL PT_ColClicked( void )
  4694. {
  4695.     ActivateGadget( PalTagGadgets[ GD_PT_COff ], PalTagWnd, NULL );
  4696.     return( TRUE );
  4697. }
  4698.  
  4699. BOOL PT_COffClicked( void )
  4700. {
  4701.     ActivateGadget( PalTagGadgets[ GD_PT_NumC ], PalTagWnd, NULL );
  4702.     return( TRUE );
  4703. }
  4704.  
  4705. BOOL PT_NumCClicked( void )
  4706. {
  4707.     return( TRUE );
  4708. }
  4709.  
  4710. BOOL PT_IWClicked( void )
  4711. {
  4712.     ActivateGadget( PalTagGadgets[ GD_PT_IH ], PalTagWnd, NULL );
  4713.     return( TRUE );
  4714. }
  4715.  
  4716. BOOL PT_IHClicked( void )
  4717. {
  4718.     return( TRUE );
  4719. }
  4720.  
  4721. BOOL PT_PosTitKeyPressed( void )
  4722. {
  4723.     if( CycleTag[1] < 5 )
  4724.     CycleTag[1] += 1;
  4725.     else
  4726.     CycleTag[1] = 0;
  4727.  
  4728.     GT_SetGadgetAttrsA( PalTagGadgets[ GD_PT_PosTit ], PalTagWnd,
  4729.             NULL, (struct TagItem *)CycleTag );
  4730.  
  4731.     PalTagMsg.Code = CycleTag[1];
  4732.  
  4733.     return( PT_PosTitClicked() );
  4734. }
  4735.  
  4736. BOOL PT_PosTitClicked( void )
  4737. {
  4738.     ULONG   t;
  4739.  
  4740.     CycleTag[1] = PalTagMsg.Code;
  4741.  
  4742.     t = ((struct GadgetInfo *)buffer3)->g_Flags & 32;
  4743.     ((struct GadgetInfo *)buffer3)->g_Flags = t | gadget_flags[ PalTagMsg.Code ];
  4744.  
  4745.     return( TRUE );
  4746. }
  4747.  
  4748. #undef gd
  4749. ///
  4750. /// Parametri SCROLLER
  4751. #define gd ((struct SK)(((struct GadgetInfo *)buffer3)->g_Data))
  4752.  
  4753. void ParametriScroller( struct GadgetInfo *gad )
  4754. {
  4755.     int     ret;
  4756.  
  4757.     LayoutWindow( SclTagWTags );
  4758.     ret = OpenSclTagWindow();
  4759.     PostOpenWindow( SclTagWTags );
  4760.  
  4761.     if( ret ) {
  4762.     DisplayBeep( Scr );
  4763.     } else {
  4764.  
  4765.     buffer3 = gad;
  4766.  
  4767.     StringTag[1] = gad->g_Titolo;
  4768.     GT_SetGadgetAttrsA( SclTagGadgets[ GD_ST_Tit ], SclTagWnd,
  4769.                 NULL, (struct TagItem *)StringTag );
  4770.  
  4771.     StringTag[1] = gad->g_Label;
  4772.     GT_SetGadgetAttrsA( SclTagGadgets[ GD_ST_Label ], SclTagWnd,
  4773.                 NULL, (struct TagItem *)StringTag );
  4774.  
  4775.     ret = 0;
  4776.     while((!( gadget_flags[ ret ] & gad->g_Flags )) && ret < 5 )
  4777.         ret += 1;
  4778.  
  4779.     CycleTag[1] = ret;
  4780.     GT_SetGadgetAttrsA( SclTagGadgets[ GD_ST_PosTit ], SclTagWnd,
  4781.                 NULL, (struct TagItem *)CycleTag );
  4782.  
  4783.     CheckedTag[1] = ( gad->g_Tags & 1 ) ? TRUE : FALSE;
  4784.     GT_SetGadgetAttrsA( SclTagGadgets[ GD_ST_Und ], SclTagWnd,
  4785.                 NULL, (struct TagItem *)CheckedTag );
  4786.  
  4787.     CheckedTag[1] = ( gad->g_Flags & NG_HIGHLABEL ) ? TRUE : FALSE;
  4788.     GT_SetGadgetAttrsA( SclTagGadgets[ GD_ST_High ], SclTagWnd,
  4789.                 NULL, (struct TagItem *)CheckedTag );
  4790.  
  4791.     CheckedTag[1] = ( gad->g_Tags & 2 ) ? TRUE : FALSE;
  4792.     GT_SetGadgetAttrsA( SclTagGadgets[ GD_ST_Disab ], SclTagWnd,
  4793.                 NULL, (struct TagItem *)CheckedTag );
  4794.  
  4795.     CheckedTag[1] = ( gad->g_Tags & 4 ) ? TRUE : FALSE;
  4796.     GT_SetGadgetAttrsA( SclTagGadgets[ GD_ST_RelVer ], SclTagWnd,
  4797.                 NULL, (struct TagItem *)CheckedTag );
  4798.  
  4799.     CheckedTag[1] = ( gad->g_Tags & 8 ) ? TRUE : FALSE;
  4800.     GT_SetGadgetAttrsA( SclTagGadgets[ GD_ST_Imm ], SclTagWnd,
  4801.                 NULL, (struct TagItem *)CheckedTag );
  4802.  
  4803.     IntegerTag[1] = gd.Top;
  4804.     GT_SetGadgetAttrsA( SclTagGadgets[ GD_ST_Top ], SclTagWnd,
  4805.                 NULL, (struct TagItem *)IntegerTag );
  4806.  
  4807.     IntegerTag[1] = gd.Tot;
  4808.     GT_SetGadgetAttrsA( SclTagGadgets[ GD_ST_Tot ], SclTagWnd,
  4809.                 NULL, (struct TagItem *)IntegerTag );
  4810.  
  4811.     IntegerTag[1] = gd.Vis;
  4812.     GT_SetGadgetAttrsA( SclTagGadgets[ GD_ST_Vis ], SclTagWnd,
  4813.                 NULL, (struct TagItem *)IntegerTag );
  4814.  
  4815.     IntegerTag[1] = gd.Arr;
  4816.     GT_SetGadgetAttrsA( SclTagGadgets[ GD_ST_Arrows ], SclTagWnd,
  4817.                 NULL, (struct TagItem *)IntegerTag );
  4818.  
  4819.     MXTag[1] = gd.Free;
  4820.     GT_SetGadgetAttrsA( SclTagGadgets[ GD_ST_Free ], SclTagWnd,
  4821.                 NULL, (struct TagItem *)MXTag );
  4822.  
  4823.     ActivateGadget( SclTagGadgets[ GD_ST_Tit ], SclTagWnd, NULL );
  4824.  
  4825.     if( gad->g_Key )
  4826.         IE.win_info->wi_NumKeys -= 1;
  4827.  
  4828.     buffer4 = (APTR)gad->g_Flags;
  4829.     buffer2 = gad->g_Tags;
  4830.     buffer  = FALSE;
  4831.  
  4832.     while( ReqHandle( SclTagWnd, HandleSclTagIDCMP ));
  4833.     }
  4834.  
  4835.     CloseSclTagWindow();
  4836. }
  4837.  
  4838. BOOL ST_TitClicked( void )
  4839. {
  4840.     ActivateGadget( SclTagGadgets[ GD_ST_Label ], SclTagWnd, NULL );
  4841.     return( TRUE );
  4842. }
  4843.  
  4844. BOOL ST_LabelClicked( void )
  4845. {
  4846.     return( TRUE );
  4847. }
  4848.  
  4849. BOOL SclTagVanillaKey( void )
  4850. {
  4851.     switch( SclTagMsg.Code ) {
  4852.     case 13:
  4853.         return( ST_OkClicked() );
  4854.     case 27:
  4855.         return( ST_AnnullaClicked() );
  4856.     }
  4857. }
  4858.  
  4859. BOOL ST_AnnullaKeyPressed( void )
  4860. {
  4861.     return( ST_AnnullaClicked() );
  4862. }
  4863.  
  4864. BOOL ST_AnnullaClicked( void )
  4865. {
  4866.     ((struct GadgetInfo *)buffer3)->g_Flags = buffer4;
  4867.     ((struct GadgetInfo *)buffer3)->g_Tags  = buffer2;
  4868.     return( FALSE );
  4869. }
  4870.  
  4871. BOOL ST_OkKeyPressed( void )
  4872. {
  4873.     return( ST_OkClicked() );
  4874. }
  4875.  
  4876. BOOL ST_OkClicked( void )
  4877. {
  4878.     buffer = TRUE;
  4879.  
  4880.     strcpy( ((struct GadgetInfo *)buffer3)->g_Titolo,
  4881.         GetString( SclTagGadgets[ GD_ST_Tit ]));
  4882.  
  4883.     STRPTR label;
  4884.  
  4885.     label = GetString( SclTagGadgets[ GD_ST_Label ]);
  4886.  
  4887.     if( label[0] )
  4888.     strcpy( ((struct GadgetInfo *)buffer3)->g_Label, label );
  4889.  
  4890.     gd.Top  = GetNumber( SclTagGadgets[ GD_ST_Top ]);
  4891.     gd.Tot  = GetNumber( SclTagGadgets[ GD_ST_Tot ]);
  4892.     gd.Vis  = GetNumber( SclTagGadgets[ GD_ST_Vis  ]);
  4893.     gd.Arr  = GetNumber( SclTagGadgets[ GD_ST_Arrows  ]);
  4894. //    gd.Free = MXTag[1];
  4895.  
  4896.     return( FALSE );
  4897. }
  4898.  
  4899. BOOL ST_UndKeyPressed( void )
  4900. {
  4901.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 1 ) ? FALSE : TRUE;
  4902.     GT_SetGadgetAttrsA( SclTagGadgets[ GD_ST_Und ], SclTagWnd,
  4903.             NULL, (struct TagItem *)CheckedTag );
  4904.  
  4905.     return( ST_UndClicked() );
  4906. }
  4907.  
  4908. BOOL ST_UndClicked( void )
  4909. {
  4910.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 1;
  4911.     return( TRUE );
  4912. }
  4913.  
  4914. BOOL ST_HighKeyPressed( void )
  4915. {
  4916.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Flags & NG_HIGHLABEL ) ? FALSE : TRUE;
  4917.     GT_SetGadgetAttrsA( SclTagGadgets[ GD_ST_High ], SclTagWnd,
  4918.             NULL, (struct TagItem *)CheckedTag );
  4919.  
  4920.     return( ST_HighClicked() );
  4921. }
  4922.  
  4923. BOOL ST_HighClicked( void )
  4924. {
  4925.     ((struct GadgetInfo *)buffer3)->g_Flags ^= NG_HIGHLABEL;
  4926.     return( TRUE );
  4927. }
  4928.  
  4929. BOOL ST_DisabKeyPressed( void )
  4930. {
  4931.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 2 ) ? FALSE : TRUE;
  4932.     GT_SetGadgetAttrsA( SclTagGadgets[ GD_ST_Disab ], SclTagWnd,
  4933.             NULL, (struct TagItem *)CheckedTag );
  4934.  
  4935.     return( ST_DisabClicked() );
  4936. }
  4937.  
  4938. BOOL ST_DisabClicked( void )
  4939. {
  4940.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 2;
  4941.     return( TRUE );
  4942. }
  4943.  
  4944. BOOL ST_RelVerKeyPressed( void )
  4945. {
  4946.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 4 ) ? FALSE : TRUE;
  4947.     GT_SetGadgetAttrsA( SclTagGadgets[ GD_ST_RelVer ], SclTagWnd,
  4948.             NULL, (struct TagItem *)CheckedTag );
  4949.  
  4950.     return( ST_RelVerClicked() );
  4951. }
  4952.  
  4953. BOOL ST_RelVerClicked( void )
  4954. {
  4955.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 4;
  4956.     return( TRUE );
  4957. }
  4958.  
  4959. BOOL ST_ImmKeyPressed( void )
  4960. {
  4961.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 8 ) ? FALSE : TRUE;
  4962.     GT_SetGadgetAttrsA( SclTagGadgets[ GD_ST_Imm ], SclTagWnd,
  4963.             NULL, (struct TagItem *)CheckedTag );
  4964.  
  4965.     return( ST_ImmClicked() );
  4966. }
  4967.  
  4968. BOOL ST_ImmClicked( void )
  4969. {
  4970.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 8;
  4971.     return( TRUE );
  4972. }
  4973.  
  4974. BOOL ST_TopClicked( void )
  4975. {
  4976.     ActivateGadget( SclTagGadgets[ GD_ST_Tot ], SclTagWnd, NULL );
  4977.     return( TRUE );
  4978. }
  4979.  
  4980. BOOL ST_TotClicked( void )
  4981. {
  4982.     ActivateGadget( SclTagGadgets[ GD_ST_Vis ], SclTagWnd, NULL );
  4983.     return( TRUE );
  4984. }
  4985.  
  4986. BOOL ST_VisClicked( void )
  4987. {
  4988.     ActivateGadget( SclTagGadgets[ GD_ST_Arrows ], SclTagWnd, NULL );
  4989.     return( TRUE );
  4990. }
  4991.  
  4992. BOOL ST_ArrowsClicked( void )
  4993. {
  4994.     return( TRUE );
  4995. }
  4996.  
  4997. BOOL ST_PosTitKeyPressed( void )
  4998. {
  4999.     if( CycleTag[1] < 5 )
  5000.     CycleTag[1] += 1;
  5001.     else
  5002.     CycleTag[1] = 0;
  5003.  
  5004.     GT_SetGadgetAttrsA( SclTagGadgets[ GD_ST_PosTit ], SclTagWnd,
  5005.             NULL, (struct TagItem *)CycleTag );
  5006.  
  5007.     SclTagMsg.Code = CycleTag[1];
  5008.  
  5009.     return( ST_PosTitClicked() );
  5010. }
  5011.  
  5012. BOOL ST_PosTitClicked( void )
  5013. {
  5014.     ULONG   t;
  5015.  
  5016.     CycleTag[1] = SclTagMsg.Code;
  5017.  
  5018.     t = ((struct GadgetInfo *)buffer3)->g_Flags & 32;
  5019.     ((struct GadgetInfo *)buffer3)->g_Flags = t | gadget_flags[ SclTagMsg.Code ];
  5020.  
  5021.     return( TRUE );
  5022. }
  5023.  
  5024. BOOL ST_FreeKeyPressed( void )
  5025. {
  5026.     if( MXTag[1] == 0 )
  5027.     MXTag[1] = 1;
  5028.     else
  5029.     MXTag[1] = 0;
  5030.  
  5031.     GT_SetGadgetAttrsA( SclTagGadgets[ GD_ST_Free ], SclTagWnd,
  5032.             NULL, (struct TagItem *)MXTag );
  5033.  
  5034.     gd.Free = MXTag[1];
  5035.  
  5036.     return( TRUE );
  5037. }
  5038.  
  5039. BOOL ST_FreeClicked( void )
  5040. {
  5041.     return( ST_FreeKeyPressed() );
  5042. }
  5043.  
  5044. #undef gd
  5045. ///
  5046. /// Parametri SLIDER
  5047. #define gd ((struct SlK)(((struct GadgetInfo *)buffer3)->g_Data))
  5048.  
  5049. void ParametriSlider( struct GadgetInfo *gad )
  5050. {
  5051.     int     ret;
  5052.  
  5053.     LayoutWindow( SliTagWTags );
  5054.     ret = OpenSliTagWindow();
  5055.     PostOpenWindow( SliTagWTags );
  5056.  
  5057.     if( ret ) {
  5058.     DisplayBeep( Scr );
  5059.     } else {
  5060.  
  5061.     buffer3 = gad;
  5062.  
  5063.     StringTag[1] = gad->g_Titolo;
  5064.     GT_SetGadgetAttrsA( SliTagGadgets[ GD_SlT_Tit ], SliTagWnd,
  5065.                 NULL, (struct TagItem *)StringTag );
  5066.  
  5067.     StringTag[1] = gad->g_Label;
  5068.     GT_SetGadgetAttrsA( SliTagGadgets[ GD_SlT_Label ], SliTagWnd,
  5069.                 NULL, (struct TagItem *)StringTag );
  5070.  
  5071.     ret = 0;
  5072.     while((!( gadget_flags[ ret ] & gad->g_Flags )) && ret < 5 )
  5073.         ret += 1;
  5074.  
  5075.     CycleTag[1] = ret;
  5076.     GT_SetGadgetAttrsA( SliTagGadgets[ GD_SlT_PosTit ], SliTagWnd,
  5077.                 NULL, (struct TagItem *)CycleTag );
  5078.  
  5079.     CheckedTag[1] = ( gad->g_Tags & 1 ) ? TRUE : FALSE;
  5080.     GT_SetGadgetAttrsA( SliTagGadgets[ GD_SlT_Und ], SliTagWnd,
  5081.                 NULL, (struct TagItem *)CheckedTag );
  5082.  
  5083.     CheckedTag[1] = ( gad->g_Flags & NG_HIGHLABEL ) ? TRUE : FALSE;
  5084.     GT_SetGadgetAttrsA( SliTagGadgets[ GD_SlT_High ], SliTagWnd,
  5085.                 NULL, (struct TagItem *)CheckedTag );
  5086.  
  5087.     CheckedTag[1] = ( gad->g_Tags & 2 ) ? TRUE : FALSE;
  5088.     GT_SetGadgetAttrsA( SliTagGadgets[ GD_SlT_Disab ], SliTagWnd,
  5089.                 NULL, (struct TagItem *)CheckedTag );
  5090.  
  5091.     CheckedTag[1] = ( gad->g_Tags & 4 ) ? TRUE : FALSE;
  5092.     GT_SetGadgetAttrsA( SliTagGadgets[ GD_SlT_RelVer ], SliTagWnd,
  5093.                 NULL, (struct TagItem *)CheckedTag );
  5094.  
  5095.     CheckedTag[1] = ( gad->g_Tags & 8 ) ? TRUE : FALSE;
  5096.     GT_SetGadgetAttrsA( SliTagGadgets[ GD_SlT_Imm ], SliTagWnd,
  5097.                 NULL, (struct TagItem *)CheckedTag );
  5098.  
  5099.     IntegerTag[1] = gd.Min;
  5100.     GT_SetGadgetAttrsA( SliTagGadgets[ GD_SlT_Min ], SliTagWnd,
  5101.                 NULL, (struct TagItem *)IntegerTag );
  5102.  
  5103.     IntegerTag[1] = gd.Max;
  5104.     GT_SetGadgetAttrsA( SliTagGadgets[ GD_SlT_Max ], SliTagWnd,
  5105.                 NULL, (struct TagItem *)IntegerTag );
  5106.  
  5107.     IntegerTag[1] = gd.Level;
  5108.     GT_SetGadgetAttrsA( SliTagGadgets[ GD_SlT_Lev ], SliTagWnd,
  5109.                 NULL, (struct TagItem *)IntegerTag );
  5110.  
  5111.     IntegerTag[1] = gd.MLL;
  5112.     GT_SetGadgetAttrsA( SliTagGadgets[ GD_SlT_MLL ], SliTagWnd,
  5113.                 NULL, (struct TagItem *)IntegerTag );
  5114.  
  5115.     IntegerTag[1] = gd.MPL;
  5116.     GT_SetGadgetAttrsA( SliTagGadgets[ GD_SlT_MPL ], SliTagWnd,
  5117.                 NULL, (struct TagItem *)IntegerTag );
  5118.  
  5119.     StringTag[1] = gd.Format;
  5120.     GT_SetGadgetAttrsA( SliTagGadgets[ GD_SlT_Fmt ], SliTagWnd,
  5121.                 NULL, (struct TagItem *)StringTag );
  5122.  
  5123.     MXTag[1] = gd.Free;
  5124.     GT_SetGadgetAttrsA( SliTagGadgets[ GD_SlT_Free ], SliTagWnd,
  5125.                 NULL, (struct TagItem *)MXTag );
  5126.  
  5127.     CycleTag2[1] = gd.Just;
  5128.     GT_SetGadgetAttrsA( SliTagGadgets[ GD_SlT_Just ], SliTagWnd,
  5129.                 NULL, (struct TagItem *)CycleTag2 );
  5130.  
  5131.     CycleTag3[1] = gd.LevPlc;
  5132.     GT_SetGadgetAttrsA( SliTagGadgets[ GD_SlT_LevPlc ], SliTagWnd,
  5133.                 NULL, (struct TagItem *)CycleTag3 );
  5134.  
  5135.     ActivateGadget( SliTagGadgets[ GD_SlT_Tit ], SliTagWnd, NULL );
  5136.  
  5137.     if( gad->g_Key )
  5138.         IE.win_info->wi_NumKeys -= 1;
  5139.  
  5140.     buffer4 = (APTR)gad->g_Flags;
  5141.     buffer2 = gad->g_Tags;
  5142.     buffer  = FALSE;
  5143.  
  5144.     while( ReqHandle( SliTagWnd, HandleSliTagIDCMP ));
  5145.     }
  5146.  
  5147.     CloseSliTagWindow();
  5148. }
  5149.  
  5150. BOOL SlT_TitClicked( void )
  5151. {
  5152.     ActivateGadget( SliTagGadgets[ GD_SlT_Label ], SliTagWnd, NULL );
  5153.     return( TRUE );
  5154. }
  5155.  
  5156. BOOL SlT_LabelClicked( void )
  5157. {
  5158.     return( TRUE );
  5159. }
  5160.  
  5161. BOOL SliTagVanillaKey( void )
  5162. {
  5163.     switch( SliTagMsg.Code ) {
  5164.     case 13:
  5165.         return( SlT_OkClicked() );
  5166.     case 27:
  5167.         return( SlT_AnnullaClicked() );
  5168.     }
  5169. }
  5170.  
  5171. BOOL SlT_AnnullaKeyPressed( void )
  5172. {
  5173.     return( SlT_AnnullaClicked() );
  5174. }
  5175.  
  5176. BOOL SlT_AnnullaClicked( void )
  5177. {
  5178.     ((struct GadgetInfo *)buffer3)->g_Flags = buffer4;
  5179.     ((struct GadgetInfo *)buffer3)->g_Tags  = buffer2;
  5180.     return( FALSE );
  5181. }
  5182.  
  5183. BOOL SlT_OkKeyPressed( void )
  5184. {
  5185.     return( SlT_OkClicked() );
  5186. }
  5187.  
  5188. BOOL SlT_OkClicked( void )
  5189. {
  5190.     buffer = TRUE;
  5191.  
  5192.     strcpy( ((struct GadgetInfo *)buffer3)->g_Titolo,
  5193.         GetString( SliTagGadgets[ GD_SlT_Tit ]));
  5194.  
  5195.     STRPTR label;
  5196.  
  5197.     label = GetString( SliTagGadgets[ GD_SlT_Label ]);
  5198.  
  5199.     if( label[0] )
  5200.     strcpy( ((struct GadgetInfo *)buffer3)->g_Label, label );
  5201.  
  5202.     strcpy( gd.Format, GetString( SliTagGadgets[ GD_SlT_Fmt ]));
  5203.  
  5204.     gd.Min    = GetNumber( SliTagGadgets[ GD_SlT_Min ]);
  5205.     gd.Max    = GetNumber( SliTagGadgets[ GD_SlT_Max ]);
  5206.     gd.Level  = GetNumber( SliTagGadgets[ GD_SlT_Lev ]);
  5207.     gd.MLL    = GetNumber( SliTagGadgets[ GD_SlT_MLL ]);
  5208.     gd.MPL    = GetNumber( SliTagGadgets[ GD_SlT_MPL ]);
  5209.     gd.Free   = MXTag[1];
  5210.     gd.Just   = CycleTag2[1];
  5211.     gd.LevPlc = CycleTag3[1];
  5212.  
  5213.     return( FALSE );
  5214. }
  5215.  
  5216. BOOL SlT_UndKeyPressed( void )
  5217. {
  5218.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 1 ) ? FALSE : TRUE;
  5219.     GT_SetGadgetAttrsA( SliTagGadgets[ GD_SlT_Und ], SliTagWnd,
  5220.             NULL, (struct TagItem *)CheckedTag );
  5221.  
  5222.     return( SlT_UndClicked() );
  5223. }
  5224.  
  5225. BOOL SlT_UndClicked( void )
  5226. {
  5227.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 1;
  5228.     return( TRUE );
  5229. }
  5230.  
  5231. BOOL SlT_HighKeyPressed( void )
  5232. {
  5233.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Flags & NG_HIGHLABEL ) ? FALSE : TRUE;
  5234.     GT_SetGadgetAttrsA( SliTagGadgets[ GD_SlT_High ], SliTagWnd,
  5235.             NULL, (struct TagItem *)CheckedTag );
  5236.  
  5237.     return( SlT_HighClicked() );
  5238. }
  5239.  
  5240. BOOL SlT_HighClicked( void )
  5241. {
  5242.     ((struct GadgetInfo *)buffer3)->g_Flags ^= NG_HIGHLABEL;
  5243.     return( TRUE );
  5244. }
  5245.  
  5246. BOOL SlT_DisabKeyPressed( void )
  5247. {
  5248.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 2 ) ? FALSE : TRUE;
  5249.     GT_SetGadgetAttrsA( SliTagGadgets[ GD_SlT_Disab ], SliTagWnd,
  5250.             NULL, (struct TagItem *)CheckedTag );
  5251.  
  5252.     return( SlT_DisabClicked() );
  5253. }
  5254.  
  5255. BOOL SlT_DisabClicked( void )
  5256. {
  5257.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 2;
  5258.     return( TRUE );
  5259. }
  5260.  
  5261. BOOL SlT_RelVerKeyPressed( void )
  5262. {
  5263.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 4 ) ? FALSE : TRUE;
  5264.     GT_SetGadgetAttrsA( SliTagGadgets[ GD_SlT_RelVer ], SliTagWnd,
  5265.             NULL, (struct TagItem *)CheckedTag );
  5266.  
  5267.     return( SlT_RelVerClicked() );
  5268. }
  5269.  
  5270. BOOL SlT_RelVerClicked( void )
  5271. {
  5272.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 4;
  5273.     return( TRUE );
  5274. }
  5275.  
  5276. BOOL SlT_ImmKeyPressed( void )
  5277. {
  5278.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 8 ) ? FALSE : TRUE;
  5279.     GT_SetGadgetAttrsA( SliTagGadgets[ GD_SlT_Imm ], SliTagWnd,
  5280.             NULL, (struct TagItem *)CheckedTag );
  5281.  
  5282.     return( SlT_ImmClicked() );
  5283. }
  5284.  
  5285. BOOL SlT_ImmClicked( void )
  5286. {
  5287.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 8;
  5288.     return( TRUE );
  5289. }
  5290.  
  5291. BOOL SlT_MinClicked( void )
  5292. {
  5293.     ActivateGadget( SliTagGadgets[ GD_SlT_Max ], SliTagWnd, NULL );
  5294.     return( TRUE );
  5295. }
  5296.  
  5297. BOOL SlT_MaxClicked( void )
  5298. {
  5299.     ActivateGadget( SliTagGadgets[ GD_SlT_Lev ], SliTagWnd, NULL );
  5300.     return( TRUE );
  5301. }
  5302.  
  5303. BOOL SlT_LevClicked( void )
  5304. {
  5305.     return( TRUE );
  5306. }
  5307.  
  5308. BOOL SlT_MLLClicked( void )
  5309. {
  5310.     ActivateGadget( SliTagGadgets[ GD_SlT_Fmt ], SliTagWnd, NULL );
  5311.     return( TRUE );
  5312. }
  5313.  
  5314. BOOL SlT_FmtClicked( void )
  5315. {
  5316.     ActivateGadget( SliTagGadgets[ GD_SlT_MPL ], SliTagWnd, NULL );
  5317.     return( TRUE );
  5318. }
  5319.  
  5320. BOOL SlT_MPLClicked( void )
  5321. {
  5322.     return( TRUE );
  5323. }
  5324.  
  5325. BOOL SlT_PosTitKeyPressed( void )
  5326. {
  5327.     if( CycleTag[1] < 5 )
  5328.     CycleTag[1] += 1;
  5329.     else
  5330.     CycleTag[1] = 0;
  5331.  
  5332.     GT_SetGadgetAttrsA( SliTagGadgets[ GD_SlT_PosTit ], SliTagWnd,
  5333.             NULL, (struct TagItem *)CycleTag );
  5334.  
  5335.     SliTagMsg.Code = CycleTag[1];
  5336.  
  5337.     return( SlT_PosTitClicked() );
  5338. }
  5339.  
  5340. BOOL SlT_PosTitClicked( void )
  5341. {
  5342.     ULONG   t;
  5343.  
  5344.     CycleTag[1] = SliTagMsg.Code;
  5345.  
  5346.     t = ((struct GadgetInfo *)buffer3)->g_Flags & 32;
  5347.     ((struct GadgetInfo *)buffer3)->g_Flags = t | gadget_flags[ SliTagMsg.Code ];
  5348.  
  5349.     return( TRUE );
  5350. }
  5351.  
  5352. BOOL SlT_FreeKeyPressed( void )
  5353. {
  5354.     if( MXTag[1] == 0 )
  5355.     MXTag[1] = 1;
  5356.     else
  5357.     MXTag[1] = 0;
  5358.  
  5359.     GT_SetGadgetAttrsA( SliTagGadgets[ GD_SlT_Free ], SliTagWnd,
  5360.             NULL, (struct TagItem *)MXTag );
  5361.  
  5362.     return( TRUE );
  5363. }
  5364.  
  5365. BOOL SlT_FreeClicked( void )
  5366. {
  5367.     return( SlT_FreeKeyPressed() );
  5368. }
  5369.  
  5370. BOOL SlT_JustKeyPressed( void )
  5371. {
  5372.     if( CycleTag2[1] < 2 )
  5373.     CycleTag2[1] += 1;
  5374.     else
  5375.     CycleTag2[1] = 0;
  5376.  
  5377.     GT_SetGadgetAttrsA( SliTagGadgets[ GD_SlT_Just ], SliTagWnd,
  5378.             NULL, (struct TagItem *)CycleTag2 );
  5379.  
  5380.     return( TRUE );
  5381. }
  5382.  
  5383. BOOL SlT_JustClicked( void )
  5384. {
  5385.     CycleTag2[1] = SliTagMsg.Code;
  5386.  
  5387.     return( TRUE );
  5388. }
  5389.  
  5390. BOOL SlT_LevPlcKeyPressed( void )
  5391. {
  5392.     if( CycleTag3[1] < 2 )
  5393.     CycleTag3[1] += 1;
  5394.     else
  5395.     CycleTag3[1] = 0;
  5396.  
  5397.     GT_SetGadgetAttrsA( SliTagGadgets[ GD_SlT_LevPlc ], SliTagWnd,
  5398.             NULL, (struct TagItem *)CycleTag3 );
  5399.  
  5400.     return( TRUE );
  5401. }
  5402.  
  5403. BOOL SlT_LevPlcClicked( void )
  5404. {
  5405.     CycleTag3[1] = SliTagMsg.Code;
  5406.  
  5407.     return( TRUE );
  5408. }
  5409.  
  5410. #undef gd
  5411. ///
  5412. /// Parametri STRING
  5413. #define gd ((struct StK)(((struct GadgetInfo *)buffer3)->g_Data))
  5414.  
  5415. void ParametriString( struct GadgetInfo *gad )
  5416. {
  5417.     int     ret;
  5418.  
  5419.     LayoutWindow( StrTagWTags );
  5420.     ret = OpenStrTagWindow();
  5421.     PostOpenWindow( StrTagWTags );
  5422.  
  5423.     if( ret ) {
  5424.     DisplayBeep( Scr );
  5425.     } else {
  5426.  
  5427.     buffer3 = gad;
  5428.  
  5429.     StringTag[1] = gad->g_Titolo;
  5430.     GT_SetGadgetAttrsA( StrTagGadgets[ GD_StrT_Tit ], StrTagWnd,
  5431.                 NULL, (struct TagItem *)StringTag );
  5432.  
  5433.     StringTag[1] = gad->g_Label;
  5434.     GT_SetGadgetAttrsA( StrTagGadgets[ GD_StrT_Label ], StrTagWnd,
  5435.                 NULL, (struct TagItem *)StringTag );
  5436.  
  5437.     ret = 0;
  5438.     while((!( gadget_flags[ ret ] & gad->g_Flags )) && ret < 5 )
  5439.         ret += 1;
  5440.  
  5441.     CycleTag[1] = ret;
  5442.     GT_SetGadgetAttrsA( StrTagGadgets[ GD_StrT_PosTit ], StrTagWnd,
  5443.                 NULL, (struct TagItem *)CycleTag );
  5444.  
  5445.     CheckedTag[1] = ( gad->g_Tags & 1 ) ? TRUE : FALSE;
  5446.     GT_SetGadgetAttrsA( StrTagGadgets[ GD_StrT_Und ], StrTagWnd,
  5447.                 NULL, (struct TagItem *)CheckedTag );
  5448.  
  5449.     CheckedTag[1] = ( gad->g_Flags & NG_HIGHLABEL ) ? TRUE : FALSE;
  5450.     GT_SetGadgetAttrsA( StrTagGadgets[ GD_StrT_High ], StrTagWnd,
  5451.                 NULL, (struct TagItem *)CheckedTag );
  5452.  
  5453.     CheckedTag[1] = ( gad->g_Tags & 2 ) ? TRUE : FALSE;
  5454.     GT_SetGadgetAttrsA( StrTagGadgets[ GD_StrT_Disab ], StrTagWnd,
  5455.                 NULL, (struct TagItem *)CheckedTag );
  5456.  
  5457.     CheckedTag[1] = ( gad->g_Tags & 4 ) ? TRUE : FALSE;
  5458.     GT_SetGadgetAttrsA( StrTagGadgets[ GD_StrT_Imm ], StrTagWnd,
  5459.                 NULL, (struct TagItem *)CheckedTag );
  5460.  
  5461.     CheckedTag[1] = ( gad->g_Tags & 8 ) ? TRUE : FALSE;
  5462.     GT_SetGadgetAttrsA( StrTagGadgets[ GD_StrT_Tab ], StrTagWnd,
  5463.                 NULL, (struct TagItem *)CheckedTag );
  5464.  
  5465.     CheckedTag[1] = ( gad->g_Tags & 0x10 ) ? TRUE : FALSE;
  5466.     GT_SetGadgetAttrsA( StrTagGadgets[ GD_StrT_Help ], StrTagWnd,
  5467.                 NULL, (struct TagItem *)CheckedTag );
  5468.  
  5469.     CheckedTag[1] = ( gad->g_Tags & 0x20 ) ? TRUE : FALSE;
  5470.     GT_SetGadgetAttrsA( StrTagGadgets[ GD_StrT_Rep ], StrTagWnd,
  5471.                 NULL, (struct TagItem *)CheckedTag );
  5472.  
  5473.     IntegerTag[1] = gd.MaxC;
  5474.     GT_SetGadgetAttrsA( StrTagGadgets[ GD_StrT_MaxC ], StrTagWnd,
  5475.                 NULL, (struct TagItem *)IntegerTag );
  5476.  
  5477.     StringTag[1] = gad->g_ExtraMem;
  5478.     GT_SetGadgetAttrsA( StrTagGadgets[ GD_StrT_Str ], StrTagWnd,
  5479.                 NULL, (struct TagItem *)StringTag );
  5480.  
  5481.     CycleTag2[1] = gd.Just;
  5482.     GT_SetGadgetAttrsA( StrTagGadgets[ GD_StrT_Just ], StrTagWnd,
  5483.                 NULL, (struct TagItem *)CycleTag2 );
  5484.  
  5485.     ActivateGadget( StrTagGadgets[ GD_StrT_Tit ], StrTagWnd, NULL );
  5486.  
  5487.     if( gad->g_Key )
  5488.         IE.win_info->wi_NumKeys -= 1;
  5489.  
  5490.     buffer4 = (APTR)gad->g_Flags;
  5491.     buffer2 = gad->g_Tags;
  5492.     buffer  = FALSE;
  5493.  
  5494.     while( ReqHandle( StrTagWnd, HandleStrTagIDCMP ));
  5495.     }
  5496.  
  5497.     CloseStrTagWindow();
  5498. }
  5499.  
  5500. BOOL StrT_TitClicked( void )
  5501. {
  5502.     ActivateGadget( StrTagGadgets[ GD_StrT_Label ], StrTagWnd, NULL );
  5503.     return( TRUE );
  5504. }
  5505.  
  5506. BOOL StrT_LabelClicked( void )
  5507. {
  5508.     return( TRUE );
  5509. }
  5510.  
  5511. BOOL StrTagVanillaKey( void )
  5512. {
  5513.     switch( StrTagMsg.Code ) {
  5514.     case 13:
  5515.         return( StrT_OkClicked() );
  5516.     case 27:
  5517.         return( StrT_AnnullaClicked() );
  5518.     }
  5519. }
  5520.  
  5521. BOOL StrT_AnnullaKeyPressed( void )
  5522. {
  5523.     return( StrT_AnnullaClicked() );
  5524. }
  5525.  
  5526. BOOL StrT_AnnullaClicked( void )
  5527. {
  5528.     ((struct GadgetInfo *)buffer3)->g_Flags = buffer4;
  5529.     ((struct GadgetInfo *)buffer3)->g_Tags  = buffer2;
  5530.     return( FALSE );
  5531. }
  5532.  
  5533. BOOL StrT_OkKeyPressed( void )
  5534. {
  5535.     return( StrT_OkClicked() );
  5536. }
  5537.  
  5538. BOOL StrT_OkClicked( void )
  5539. {
  5540.     buffer = TRUE;
  5541.  
  5542.     strcpy( ((struct GadgetInfo *)buffer3)->g_Titolo,
  5543.         GetString( StrTagGadgets[ GD_StrT_Tit ]));
  5544.  
  5545.     STRPTR label;
  5546.  
  5547.     label = GetString( StrTagGadgets[ GD_StrT_Label ]);
  5548.  
  5549.     if( label[0] )
  5550.     strcpy( ((struct GadgetInfo *)buffer3)->g_Label, label );
  5551.  
  5552.     strcpy( ((struct GadgetInfo *)buffer3)->g_ExtraMem,
  5553.         GetString( StrTagGadgets[ GD_StrT_Str ]));
  5554.  
  5555.     gd.MaxC = GetNumber( StrTagGadgets[ GD_StrT_MaxC ]);
  5556.     gd.Just = CycleTag2[1];
  5557.  
  5558.     return( FALSE );
  5559. }
  5560.  
  5561. BOOL StrT_UndKeyPressed( void )
  5562. {
  5563.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 1 ) ? FALSE : TRUE;
  5564.     GT_SetGadgetAttrsA( StrTagGadgets[ GD_StrT_Und ], StrTagWnd,
  5565.             NULL, (struct TagItem *)CheckedTag );
  5566.  
  5567.     return( StrT_UndClicked() );
  5568. }
  5569.  
  5570. BOOL StrT_UndClicked( void )
  5571. {
  5572.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 1;
  5573.     return( TRUE );
  5574. }
  5575.  
  5576. BOOL StrT_HighKeyPressed( void )
  5577. {
  5578.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Flags & NG_HIGHLABEL ) ? FALSE : TRUE;
  5579.     GT_SetGadgetAttrsA( StrTagGadgets[ GD_StrT_High ], StrTagWnd,
  5580.             NULL, (struct TagItem *)CheckedTag );
  5581.  
  5582.     return( StrT_HighClicked() );
  5583. }
  5584.  
  5585. BOOL StrT_HighClicked( void )
  5586. {
  5587.     ((struct GadgetInfo *)buffer3)->g_Flags ^= NG_HIGHLABEL;
  5588.     return( TRUE );
  5589. }
  5590.  
  5591. BOOL StrT_DisabKeyPressed( void )
  5592. {
  5593.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 2 ) ? FALSE : TRUE;
  5594.     GT_SetGadgetAttrsA( StrTagGadgets[ GD_StrT_Disab ], StrTagWnd,
  5595.             NULL, (struct TagItem *)CheckedTag );
  5596.  
  5597.     return( StrT_DisabClicked() );
  5598. }
  5599.  
  5600. BOOL StrT_DisabClicked( void )
  5601. {
  5602.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 2;
  5603.     return( TRUE );
  5604. }
  5605.  
  5606. BOOL StrT_ImmKeyPressed( void )
  5607. {
  5608.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 4 ) ? FALSE : TRUE;
  5609.     GT_SetGadgetAttrsA( StrTagGadgets[ GD_StrT_Imm ], StrTagWnd,
  5610.             NULL, (struct TagItem *)CheckedTag );
  5611.  
  5612.     return( StrT_ImmClicked() );
  5613. }
  5614.  
  5615. BOOL StrT_ImmClicked( void )
  5616. {
  5617.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 4;
  5618.     return( TRUE );
  5619. }
  5620.  
  5621. BOOL StrT_TabKeyPressed( void )
  5622. {
  5623.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 8 ) ? FALSE : TRUE;
  5624.     GT_SetGadgetAttrsA( StrTagGadgets[ GD_StrT_Tab ], StrTagWnd,
  5625.             NULL, (struct TagItem *)CheckedTag );
  5626.  
  5627.     return( StrT_TabClicked() );
  5628. }
  5629.  
  5630. BOOL StrT_TabClicked( void )
  5631. {
  5632.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 8;
  5633.     return( TRUE );
  5634. }
  5635.  
  5636. BOOL StrT_HelpKeyPressed( void )
  5637. {
  5638.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 0x10 ) ? FALSE : TRUE;
  5639.     GT_SetGadgetAttrsA( StrTagGadgets[ GD_StrT_Help ], StrTagWnd,
  5640.             NULL, (struct TagItem *)CheckedTag );
  5641.  
  5642.     return( StrT_HelpClicked() );
  5643. }
  5644.  
  5645. BOOL StrT_HelpClicked( void )
  5646. {
  5647.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 0x10;
  5648.     return( TRUE );
  5649. }
  5650.  
  5651. BOOL StrT_RepKeyPressed( void )
  5652. {
  5653.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 0x20 ) ? FALSE : TRUE;
  5654.     GT_SetGadgetAttrsA( StrTagGadgets[ GD_StrT_Rep ], StrTagWnd,
  5655.             NULL, (struct TagItem *)CheckedTag );
  5656.  
  5657.     return( StrT_RepClicked() );
  5658. }
  5659.  
  5660. BOOL StrT_RepClicked( void )
  5661. {
  5662.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 0x20;
  5663.     return( TRUE );
  5664. }
  5665.  
  5666. BOOL StrT_MaxCClicked( void )
  5667. {
  5668.     ActivateGadget( StrTagGadgets[ GD_StrT_Str ], StrTagWnd, NULL );
  5669.     return( TRUE );
  5670. }
  5671.  
  5672. BOOL StrT_StrClicked( void )
  5673. {
  5674.     return( TRUE );
  5675. }
  5676.  
  5677. BOOL StrT_PosTitKeyPressed( void )
  5678. {
  5679.     if( CycleTag[1] < 5 )
  5680.     CycleTag[1] += 1;
  5681.     else
  5682.     CycleTag[1] = 0;
  5683.  
  5684.     GT_SetGadgetAttrsA( StrTagGadgets[ GD_StrT_PosTit ], StrTagWnd,
  5685.             NULL, (struct TagItem *)CycleTag );
  5686.  
  5687.     StrTagMsg.Code = CycleTag[1];
  5688.  
  5689.     return( StrT_PosTitClicked() );
  5690. }
  5691.  
  5692. BOOL StrT_PosTitClicked( void )
  5693. {
  5694.     ULONG   t;
  5695.  
  5696.     CycleTag[1] = StrTagMsg.Code;
  5697.  
  5698.     t = ((struct GadgetInfo *)buffer3)->g_Flags & 32;
  5699.     ((struct GadgetInfo *)buffer3)->g_Flags = t | gadget_flags[ StrTagMsg.Code ];
  5700.  
  5701.     return( TRUE );
  5702. }
  5703.  
  5704. BOOL StrT_JustKeyPressed( void )
  5705. {
  5706.     if( CycleTag2[1] < 2 )
  5707.     CycleTag2[1] += 1;
  5708.     else
  5709.     CycleTag2[1] = 0;
  5710.  
  5711.     GT_SetGadgetAttrsA( StrTagGadgets[ GD_StrT_Just ], StrTagWnd,
  5712.             NULL, (struct TagItem *)CycleTag2 );
  5713.  
  5714.     return( TRUE );
  5715. }
  5716.  
  5717. BOOL StrT_JustClicked( void )
  5718. {
  5719.     CycleTag2[1] = StrTagMsg.Code;
  5720.  
  5721.     return( TRUE );
  5722. }
  5723.  
  5724. #undef gd
  5725. ///
  5726. /// Parametri TEXT
  5727. #define gd ((struct TK)(((struct GadgetInfo *)buffer3)->g_Data))
  5728.  
  5729. void ParametriText( struct GadgetInfo *gad )
  5730. {
  5731.     int     ret;
  5732.  
  5733.     LayoutWindow( TxtTagWTags );
  5734.     ret = OpenTxtTagWindow();
  5735.     PostOpenWindow( TxtTagWTags );
  5736.  
  5737.     if( ret ) {
  5738.     DisplayBeep( Scr );
  5739.     } else {
  5740.  
  5741.     buffer3 = gad;
  5742.  
  5743.     StringTag[1] = gad->g_Titolo;
  5744.     GT_SetGadgetAttrsA( TxtTagGadgets[ GD_TT_Tit ], TxtTagWnd,
  5745.                 NULL, (struct TagItem *)StringTag );
  5746.  
  5747.     StringTag[1] = gad->g_Label;
  5748.     GT_SetGadgetAttrsA( TxtTagGadgets[ GD_TT_Label ], TxtTagWnd,
  5749.                 NULL, (struct TagItem *)StringTag );
  5750.  
  5751.     ret = 0;
  5752.     while((!( gadget_flags[ ret ] & gad->g_Flags )) && ret < 5 )
  5753.         ret += 1;
  5754.  
  5755.     CycleTag[1] = ret;
  5756.     GT_SetGadgetAttrsA( TxtTagGadgets[ GD_TT_PosTit ], TxtTagWnd,
  5757.                 NULL, (struct TagItem *)CycleTag );
  5758.  
  5759.     CheckedTag[1] = ( gad->g_Tags & 1 ) ? TRUE : FALSE;
  5760.     GT_SetGadgetAttrsA( TxtTagGadgets[ GD_TT_Und ], TxtTagWnd,
  5761.                 NULL, (struct TagItem *)CheckedTag );
  5762.  
  5763.     CheckedTag[1] = ( gad->g_Flags & NG_HIGHLABEL ) ? TRUE : FALSE;
  5764.     GT_SetGadgetAttrsA( TxtTagGadgets[ GD_TT_High ], TxtTagWnd,
  5765.                 NULL, (struct TagItem *)CheckedTag );
  5766.  
  5767.     CheckedTag[1] = ( gad->g_Tags & 2 ) ? TRUE : FALSE;
  5768.     GT_SetGadgetAttrsA( TxtTagGadgets[ GD_TT_Copy ], TxtTagWnd,
  5769.                 NULL, (struct TagItem *)CheckedTag );
  5770.  
  5771.     CheckedTag[1] = ( gad->g_Tags & 4 ) ? TRUE : FALSE;
  5772.     GT_SetGadgetAttrsA( TxtTagGadgets[ GD_TT_Border ], TxtTagWnd,
  5773.                 NULL, (struct TagItem *)CheckedTag );
  5774.  
  5775.     CheckedTag[1] = ( gad->g_Tags & 8 ) ? TRUE : FALSE;
  5776.     GT_SetGadgetAttrsA( TxtTagGadgets[ GD_TT_Clip ], TxtTagWnd,
  5777.                 NULL, (struct TagItem *)CheckedTag );
  5778.  
  5779.     IntegerTag[1] = gd.FPen;
  5780.     GT_SetGadgetAttrsA( TxtTagGadgets[ GD_TT_FPen ], TxtTagWnd,
  5781.                 NULL, (struct TagItem *)IntegerTag );
  5782.  
  5783.     IntegerTag[1] = gd.BPen;
  5784.     GT_SetGadgetAttrsA( TxtTagGadgets[ GD_TT_BPen ], TxtTagWnd,
  5785.                 NULL, (struct TagItem *)IntegerTag );
  5786.  
  5787.     StringTag[1] = gad->g_ExtraMem;
  5788.     GT_SetGadgetAttrsA( TxtTagGadgets[ GD_TT_Txt ], TxtTagWnd,
  5789.                 NULL, (struct TagItem *)StringTag );
  5790.  
  5791.     CycleTag2[1] = gd.Just;
  5792.     GT_SetGadgetAttrsA( TxtTagGadgets[ GD_TT_Just ], TxtTagWnd,
  5793.                 NULL, (struct TagItem *)CycleTag2 );
  5794.  
  5795.     ActivateGadget( TxtTagGadgets[ GD_TT_Tit ], TxtTagWnd, NULL );
  5796.  
  5797.     if( gad->g_Key )
  5798.         IE.win_info->wi_NumKeys -= 1;
  5799.  
  5800.     buffer4 = (APTR)gad->g_Flags;
  5801.     buffer2 = gad->g_Tags;
  5802.     buffer  = FALSE;
  5803.  
  5804.     while( ReqHandle( TxtTagWnd, HandleTxtTagIDCMP ));
  5805.     }
  5806.  
  5807.     CloseTxtTagWindow();
  5808. }
  5809.  
  5810. BOOL TT_TitClicked( void )
  5811. {
  5812.     ActivateGadget( TxtTagGadgets[ GD_TT_Label ], TxtTagWnd, NULL );
  5813.     return( TRUE );
  5814. }
  5815.  
  5816. BOOL TT_LabelClicked( void )
  5817. {
  5818.     return( TRUE );
  5819. }
  5820.  
  5821. BOOL TxtTagVanillaKey( void )
  5822. {
  5823.     switch( TxtTagMsg.Code ) {
  5824.     case 13:
  5825.         return( TT_OkClicked() );
  5826.     case 27:
  5827.         return( TT_AnnullaClicked() );
  5828.     }
  5829. }
  5830.  
  5831. BOOL TT_AnnullaKeyPressed( void )
  5832. {
  5833.     return( TT_AnnullaClicked() );
  5834. }
  5835.  
  5836. BOOL TT_AnnullaClicked( void )
  5837. {
  5838.     ((struct GadgetInfo *)buffer3)->g_Flags = buffer4;
  5839.     ((struct GadgetInfo *)buffer3)->g_Tags  = buffer2;
  5840.     return( FALSE );
  5841. }
  5842.  
  5843. BOOL TT_OkKeyPressed( void )
  5844. {
  5845.     return( TT_OkClicked() );
  5846. }
  5847.  
  5848. BOOL TT_OkClicked( void )
  5849. {
  5850.     STRPTR label;
  5851.  
  5852.     buffer = TRUE;
  5853.  
  5854.     strcpy( ((struct GadgetInfo *)buffer3)->g_Titolo,
  5855.         GetString( TxtTagGadgets[ GD_TT_Tit ]));
  5856.  
  5857.     label = GetString( TxtTagGadgets[ GD_TT_Label ]);
  5858.  
  5859.     if( label[0] )
  5860.     strcpy( ((struct GadgetInfo *)buffer3)->g_Label, label );
  5861.  
  5862.     strcpy( ((struct GadgetInfo *)buffer3)->g_ExtraMem,
  5863.         GetString( TxtTagGadgets[ GD_TT_Txt ]));
  5864.  
  5865.     gd.FPen = GetNumber( TxtTagGadgets[ GD_TT_FPen ]);
  5866.     gd.BPen = GetNumber( TxtTagGadgets[ GD_TT_BPen ]);
  5867.     gd.Just = CycleTag2[1];
  5868.  
  5869.     return( FALSE );
  5870. }
  5871.  
  5872. BOOL TT_UndKeyPressed( void )
  5873. {
  5874.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 1 ) ? FALSE : TRUE;
  5875.     GT_SetGadgetAttrsA( TxtTagGadgets[ GD_TT_Und ], TxtTagWnd,
  5876.             NULL, (struct TagItem *)CheckedTag );
  5877.  
  5878.     return( TT_UndClicked() );
  5879. }
  5880.  
  5881. BOOL TT_UndClicked( void )
  5882. {
  5883.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 1;
  5884.     return( TRUE );
  5885. }
  5886.  
  5887. BOOL TT_HighKeyPressed( void )
  5888. {
  5889.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Flags & NG_HIGHLABEL ) ? FALSE : TRUE;
  5890.     GT_SetGadgetAttrsA( TxtTagGadgets[ GD_TT_High ], TxtTagWnd,
  5891.             NULL, (struct TagItem *)CheckedTag );
  5892.  
  5893.     return( TT_HighClicked() );
  5894. }
  5895.  
  5896. BOOL TT_HighClicked( void )
  5897. {
  5898.     ((struct GadgetInfo *)buffer3)->g_Flags ^= NG_HIGHLABEL;
  5899.     return( TRUE );
  5900. }
  5901.  
  5902. BOOL TT_CopyKeyPressed( void )
  5903. {
  5904.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 2 ) ? FALSE : TRUE;
  5905.     GT_SetGadgetAttrsA( TxtTagGadgets[ GD_TT_Copy ], TxtTagWnd,
  5906.             NULL, (struct TagItem *)CheckedTag );
  5907.  
  5908.     return( TT_CopyClicked() );
  5909. }
  5910.  
  5911. BOOL TT_CopyClicked( void )
  5912. {
  5913.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 2;
  5914.     return( TRUE );
  5915. }
  5916.  
  5917. BOOL TT_BorderKeyPressed( void )
  5918. {
  5919.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 4 ) ? FALSE : TRUE;
  5920.     GT_SetGadgetAttrsA( TxtTagGadgets[ GD_TT_Border ], TxtTagWnd,
  5921.             NULL, (struct TagItem *)CheckedTag );
  5922.  
  5923.     return( TT_BorderClicked() );
  5924. }
  5925.  
  5926. BOOL TT_BorderClicked( void )
  5927. {
  5928.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 4;
  5929.     return( TRUE );
  5930. }
  5931.  
  5932. BOOL TT_ClipKeyPressed( void )
  5933. {
  5934.     CheckedTag[1] = (((struct GadgetInfo *)buffer3)->g_Tags & 8 ) ? FALSE : TRUE;
  5935.     GT_SetGadgetAttrsA( TxtTagGadgets[ GD_TT_Clip ], TxtTagWnd,
  5936.             NULL, (struct TagItem *)CheckedTag );
  5937.  
  5938.     return( TT_ClipClicked() );
  5939. }
  5940.  
  5941. BOOL TT_ClipClicked( void )
  5942. {
  5943.     ((struct GadgetInfo *)buffer3)->g_Tags ^= 8;
  5944.     return( TRUE );
  5945. }
  5946.  
  5947. BOOL TT_FPenClicked( void )
  5948. {
  5949.     ActivateGadget( TxtTagGadgets[ GD_TT_BPen ], TxtTagWnd, NULL );
  5950.     return( TRUE );
  5951. }
  5952.  
  5953. BOOL TT_BPenClicked( void )
  5954. {
  5955.     ActivateGadget( TxtTagGadgets[ GD_TT_Txt ], TxtTagWnd, NULL );
  5956.     return( TRUE );
  5957. }
  5958.  
  5959. BOOL TT_TxtClicked( void )
  5960. {
  5961.     return( TRUE );
  5962. }
  5963.  
  5964. BOOL TT_PosTitKeyPressed( void )
  5965. {
  5966.     if( CycleTag[1] < 5 )
  5967.     CycleTag[1] += 1;
  5968.     else
  5969.     CycleTag[1] = 0;
  5970.  
  5971.     GT_SetGadgetAttrsA( TxtTagGadgets[ GD_TT_PosTit ], TxtTagWnd,
  5972.             NULL, (struct TagItem *)CycleTag );
  5973.  
  5974.     TxtTagMsg.Code = CycleTag[1];
  5975.  
  5976.     return( TT_PosTitClicked() );
  5977. }
  5978.  
  5979. BOOL TT_PosTitClicked( void )
  5980. {
  5981.     ULONG   t;
  5982.  
  5983.     CycleTag[1] = TxtTagMsg.Code;
  5984.  
  5985.     t = ((struct GadgetInfo *)buffer3)->g_Flags & 32;
  5986.     ((struct GadgetInfo *)buffer3)->g_Flags = t | gadget_flags[ TxtTagMsg.Code ];
  5987.  
  5988.     return( TRUE );
  5989. }
  5990.  
  5991. BOOL TT_JustKeyPressed( void )
  5992. {
  5993.     if( CycleTag2[1] < 2 )
  5994.     CycleTag2[1] += 1;
  5995.     else
  5996.     CycleTag2[1] = 0;
  5997.  
  5998.     GT_SetGadgetAttrsA( TxtTagGadgets[ GD_TT_Just ], TxtTagWnd,
  5999.             NULL, (struct TagItem *)CycleTag2 );
  6000.  
  6001.     return( TRUE );
  6002. }
  6003.  
  6004. BOOL TT_JustClicked( void )
  6005. {
  6006.     CycleTag2[1] = TxtTagMsg.Code;
  6007.  
  6008.     return( TRUE );
  6009. }
  6010.  
  6011. #undef gd
  6012. ///
  6013.